Startleitfaden für Objective-C

In dieser Entwickleranleitung wird beschrieben, wie Sie Google Tag Manager in einer mobilen Anwendung implementieren.

Einführung

Mit Google Tag Manager können Entwickler Konfigurationswerte in ihren mobilen Anwendungen über die Google Tag Manager-Oberfläche ändern, ohne Anwendungsbinärdateien neu erstellen und an App-Marktplätze senden zu müssen.

Das ist nützlich, um Konfigurationswerte oder Flags in Ihrer Anwendung zu verwalten, die Sie in Zukunft möglicherweise ändern müssen, darunter:

  • Verschiedene UI-Einstellungen und Anzeigetexte
  • Größen, Standorte oder Typen von Anzeigen, die in Ihrer Anwendung ausgeliefert werden
  • Spieleinstellungen

Konfigurationswerte können auch zur Laufzeit mithilfe von Regeln ausgewertet werden, um dynamische Konfigurationen zu ermöglichen, z. B.:

  • Anzeigengröße anhand der Bildschirmgröße bestimmen
  • UI-Elemente anhand von Sprache und Standort konfigurieren

Mit Google Tag Manager lassen sich auch Tracking-Tags und ‑Pixel dynamisch in Anwendungen implementieren. Entwickler können wichtige Ereignisse in eine Daten schicht übertragen und später entscheiden, welche Tracking-Tags oder ‑Pixel ausgelöst werden sollen. Tag Manager unterstützt die folgenden Tags:

  • Google Mobile App Analytics
  • Benutzerdefiniertes Funktionsaufruf-Tag

Vorbereitung

Bevor Sie diese Anleitung verwenden, benötigen Sie Folgendes:

Wenn Sie noch nicht mit Google Tag Manager vertraut sind, empfehlen wir Ihnen, sich zuerst über Container, Makros und Regeln zu informieren (Hilfe) , bevor Sie mit dieser Anleitung fortfahren.

Erste Schritte

In diesem Abschnitt wird ein typischer Tag Manager-Workflow für Entwickler beschrieben:

  1. Google Tag Manager SDK in Ihr Projekt einbinden
  2. Standardcontainerwerte festlegen
  3. Container öffnen
  4. Konfigurationswerte aus dem Container abrufen
  5. Ereignisse an die Datenschicht übertragen
  6. Container als Vorschau ansehen und veröffentlichen

1. Google Tag Manager SDK in Ihr Projekt einbinden

Bevor Sie das Google Tag Manager SDK verwenden können, müssen Sie libGoogleAnalyticsServices.a und die Google Tag Manager-Headerdateien (GTM) aus dem Verzeichnis Library des SDK-Pakets in Ihr Projekt einbinden.

Fügen Sie dann die folgenden verknüpften Bibliotheken dem Ziel Ihrer Anwendung hinzu, falls sie noch nicht vorhanden sind:

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

Wenn Ihre Anwendung über die Google Tag Manager SDK-Makros auf die IDFA (Identifier for Advertising) und das Tracking-Flag zugreifen soll, die von diesem Framework bereitgestellt werden, müssen Sie auch die folgenden zusätzlichen Bibliotheken verknüpfen:

  • libAdIdAccess.a
  • AdSupport.framework

2. Standardcontainerdatei zu Ihrem Projekt hinzufügen

Google Tag Manager verwendet beim ersten Ausführen Ihrer Anwendung einen Standardcontainer. Der Standard Container wird verwendet, bis die App einen neuen Container über das Netzwerk abrufen kann.

So laden Sie eine binäre Standardcontainerdatei herunter und fügen sie Ihrer Anwendung hinzu:

  1. Melden Sie sich in der Google Tag Manager-Weboberfläche an.
  2. Wählen Sie die Version des Containers aus, die Sie herunterladen möchten.
  3. Klicken Sie auf die Schaltfläche Herunterladen , um die Containerbinärdatei abzurufen.
  4. Fügen Sie die Binärdatei dem Stammverzeichnis Ihres Projekts und dem Ordner „Supporting Files“ in Ihrem Projekt hinzu.

Der Standarddateiname sollte die Container-ID sein (z. B. GTM-1234). Entfernen Sie nach dem Herunterladen der Binärdatei das Versionssuffix aus dem Dateinamen, damit Sie die richtige Namenskonvention einhalten.

Die Verwendung der Binärdatei wird empfohlen. Wenn Ihr Container jedoch keine Regeln oder Tags enthält, können Sie stattdessen eine Eigenschaftsliste oder eine JSON-Datei verwenden. Die Datei sollte sich im Hauptbundle befinden und dieser Namenskonvention folgen: <Container_ID>.<plist|json>. Wenn Ihre Container-ID beispielsweise GTM-1234 ist, können Sie die Standardcontainerwerte in einer Eigenschaftslistendatei mit dem Namen GTM-1234.plist angeben.

3. Container öffnen

Bevor Sie Werte aus einem Container abrufen können, muss Ihre Anwendung den Container öffnen. Wenn Sie einen Container öffnen, wird er von der Festplatte geladen (falls verfügbar) oder über das Netzwerk angefordert (falls erforderlich).

Die einfachste Möglichkeit, einen Container unter iOS zu öffnen, ist die Verwendung von openContainerWithId:tagManager:openType:timeout:notifier:, wie im folgenden Beispiel:

// 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. Konfigurationswerte aus dem Container abrufen

Sobald der Container geöffnet ist, können Konfigurationswerte mit den <type>ForKey: Methoden abgerufen werden:

// 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"];

Anfragen mit einem nicht vorhandenen Schlüssel geben einen Standardwert zurück, der dem angeforderten Typ entspricht:

// 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. Werte an die Datenschicht übertragen

Die Datenschicht ist eine Map, mit der Laufzeitinformationen zu Ihrer App, z. B. Touch Ereignisse oder Bildschirmansichten, für Tag Manager-Makros und ‑Tags in einem Container verfügbar gemacht werden können.

Wenn Sie beispielsweise Informationen zu Bildschirmansichten in die Datenschicht-Map übertragen, können Sie in der Tag Manager-Weboberfläche Tags einrichten, um Conversion-Pixel und Tracking-Aufrufe als Reaktion auf diese Bildschirmansichten auszulösen, ohne sie in Ihre App hart codieren zu müssen.

Ereignisse werden mit push: an die Datenschicht übertragen:

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

In der Weboberfläche können Sie jetzt Tags (z. B. Google Analytics-Tags) erstellen, die für jeden Bildschirmaufruf ausgelöst werden, indem Sie diese Regel erstellen: equals "openScreen". Wenn Sie den Bildschirmnamen an eines dieser Tags übergeben möchten, erstellen Sie ein Datenschicht-Makro, das auf den Schlüssel „screenName“ in der Datenschicht verweist. Sie können auch ein Tag (z. B. ein Google Ads-Conversion-Pixel) erstellen, das nur für bestimmte Bildschirmansichten ausgelöst wird, indem Sie eine Regel erstellen, bei der equals "openScreen" && equals "ConfirmationScreen".

6. Container als Vorschau ansehen und veröffentlichen

Makrowerte entsprechen immer der aktuellen veröffentlichten Version. Bevor Sie die neueste Version eines Containers veröffentlichen, können Sie sich eine Vorschau Ihres Containerentwurfs ansehen.

Wenn Sie sich eine Vorschau eines Containers ansehen möchten, generieren Sie in der Google Tag Manager-Weboberfläche eine Vorschau-URL. Wählen Sie dazu die Version des Containers aus, die Sie als Vorschau ansehen möchten, und wählen Sie dann Preview aus. Speichern Sie diese Vorschau-URL, da Sie sie in späteren Schritten benötigen.

Vorschau-URLs sind im Vorschaufenster der Tag Manager-Weboberfläche verfügbar.
Abbildung 1: Vorschau-URL aus der Tag Manager-Weboberfläche abrufen.

Wenn Sie Container-Vorschauen aktivieren möchten, müssen Sie Ihrer App-Delegate-Implementierungsdatei Code hinzufügen und das Google Tag Manager-Vorschau-URL-Schema in der Eigenschaftsliste Ihres Projekts definieren.

Fügen Sie zuerst die folgenden fett hervorgehobenen Code-Snippets Ihrer App-Delegate-Datei hinzu:

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

Registrieren Sie dann den folgenden URL-Bezeichner und das folgende URL-Schema unter dem Schlüssel für die URL-Typen in der Eigenschaftslistendatei Ihrer Anwendung:

URL identifier: your.package_name
URL scheme: tagmanager.c.your.package.name
Registrieren Sie das Tag Manager-Vorschau-URL-Schema in der Eigenschaftslistendatei Ihrer Anwendung.
Abbildung 3: Eigenschaftslistendatei Ihrer Anwendung das Tag Manager-Vorschau-URL-Schema hinzufügen.

Öffnen Sie den Link in einem Emulator oder auf einem physischen Gerät, um sich eine Vorschau des Containerentwurfs in Ihrer App anzusehen.

Wenn Sie die Konfigurationswerte Ihres Entwurfs für Ihre Anwendung verfügbar machen möchten, veröffentlichen Sie den Container.

Erweiterte Konfiguration

Google Tag Manager for Mobile bietet eine Reihe erweiterter Konfigurationsoptionen, mit denen Sie Werte basierend auf Laufzeitbedingungen mithilfe von Regeln auswählen, den Container manuell aktualisieren und zusätzliche Optionen zum Öffnen von Containern erhalten können. In den folgenden Abschnitten werden einige der häufigsten erweiterten Konfigurationen beschrieben.

Erweiterte Optionen zum Öffnen von Containern

Das Google Tag Manager SDK bietet mehrere Methoden zum Öffnen von Containern, mit denen Sie den Ladevorgang besser steuern können:

openContainerById:callback:

openContainerById:callback: ist die API der niedrigsten Ebene und die flexibelste API zum Öffnen eines Containers. Sie gibt sofort einen Standardcontainer zurück und lädt auch asynchron einen Container von der Festplatte oder aus dem Netzwerk, wenn kein gespeicherter Container vorhanden ist oder der gespeicherte Container nicht aktuell ist (älter als 12 Stunden).

@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ährend des Ladevorgangs gibt openContainerById:callback: mehrere Lifecycle-Callbacks aus, damit Ihr Code ermitteln kann, wann die Ladeanfrage beginnt, ob und warum sie fehlschlägt oder erfolgreich ist und ob der Container letztendlich von der Festplatte oder aus dem Netzwerk geladen wurde.

Sofern es für Ihre Anwendung akzeptabel ist, die Standardwerte zu verwenden, müssen Sie diese Callbacks verwenden, um zu erfahren, wann ein gespeicherter oder Netzwerkcontainer geladen wurde. Beachten Sie, dass Sie keinen gespeicherten oder Netzwerkcontainer laden können, wenn die App zum ersten Mal ausgeführt wird und keine Netzwerkverbindung besteht.

openContainerById:callback: übergibt die folgenden enum-Werte als Argumente an diese Callbacks:

RefreshType

WertBeschreibung
kTAGContainerCallbackRefreshTypeSaved Die Aktualisierungsanfrage lädt einen lokal gespeicherten Container.
kTAGContainerCallbackRefreshTypeNetwork Die Aktualisierungsanfrage lädt einen Container über das Netzwerk.

RefreshFailure

WertBeschreibung
kTAGContainerCallbackRefreshFailureNoSavedContainer Es ist kein gespeicherter Container verfügbar.
kTAGContainerCallbackRefreshFailureIoError Ein E/A-Fehler hat die Aktualisierung des Containers verhindert.
kTAGContainerCallbackRefreshFailureNoNetwork Es ist keine Netzwerkverbindung verfügbar.
kTAGContainerCallbackRefreshFailureNetworkError Ein Netzwerkfehler ist aufgetreten.
kTAGContainerCallbackRefreshFailureServerError Auf dem Server ist ein Fehler aufgetreten.
kTAGContainerCallbackRefreshFailureUnknownError Ein Fehler ist aufgetreten, der nicht kategorisiert werden kann.

Methoden zum Öffnen von nicht standardmäßigen und neuen Containern

TAGContainerOpener umschließt openContainerById:callback: und bietet zwei praktische Methoden zum Öffnen von Containern: openContainerWithId:tagManager:openType:timeout:notifier: und openContainerWithId:tagManager:openType:timeout:.

Jede dieser Methoden verwendet eine Enumeration, die entweder einen nicht standardmäßigen oder einen neuen Container anfordert.

kTAGOpenTypePreferNonDefault wird für die meisten Anwendungen empfohlen und versucht, innerhalb eines bestimmten Zeitlimits den ersten verfügbaren nicht standardmäßigen Container von der Festplatte oder aus dem Netzwerk zurückzugeben, auch wenn dieser Container älter als 12 Stunden ist. Wenn ein veralteter gespeicherter Container zurückgegeben wird, wird auch eine asynchrone Netzwerkanfrage für einen neuen Container gestellt. Bei Verwendung von kTAGOpenTypePreferNonDefault wird ein Standardcontainer zurückgegeben, wenn kein anderer Container verfügbar ist oder das Zeitlimit überschritten wird.

kTAGOpenTypePreferFresh versucht, innerhalb des angegebenen Zeitlimits einen neuen Container von der Festplatte oder aus dem Netzwerk zurückzugeben. Wenn keine Netzwerkverbindung verfügbar ist und/oder das Zeitlimit überschritten wird, wird ein gespeicherter Container zurückgegeben.

Es wird nicht empfohlen, kTAGOpenTypePreferFresh an Stellen zu verwenden, an denen eine längere Anfragezeit die Nutzerfreundlichkeit spürbar beeinträchtigen kann, z. B. bei UI-Flags oder Anzeigetexten. Sie können auch jederzeit TAGContainer::refresh verwenden, um eine Netzwerkanfrage für einen Container zu erzwingen.

Beide praktischen Methoden sind nicht blockierend. openContainerWithId:tagManager:openType:timeout: gibt ein TAGContainerFuture-Objekt zurück, dessen get-Methode ein TAGContainer zurückgibt, sobald es geladen wurde (blockiert aber bis dahin). Die Methode openContainerWithId:tagManager:openType:timeout:notifier: verwendet einen einzelnen Callback, der aufgerufen wird, wenn der Container verfügbar ist. Beide Methoden haben ein Standardzeitlimit von 2.0 Sekunden.

Makros zur Laufzeit mithilfe von Regeln auswerten

Container können Werte zur Laufzeit mithilfe von Regeln auswerten. Regeln können auf Kriterien wie Gerätesprache, Plattform oder einem beliebigen anderen Makrowert basieren. Mit Regeln kann beispielsweise zur Laufzeit ein lokalisierter Anzeigetext basierend auf der Sprache des Geräts ausgewählt werden. Das lässt sich mit der folgenden Regel konfigurieren:

Mit einer Regel werden zur Laufzeit Anzeigestrings basierend auf der Gerätesprache ausgewählt: language = es. Für diese Regel wird das vordefinierte Sprachmakro und ein zweistelliger ISO 639-1-Sprachcode verwendet.
Abbildung 1:Regel hinzufügen, um ein Makro zur Wertsammlung nur für Geräte zu aktivieren, die für die Verwendung der spanischen Sprache konfiguriert sind.

Sie können dann Makros zur Wertsammlung für jede Sprache erstellen und diese Regel jedem Makro hinzufügen, indem Sie den entsprechenden Sprachcode einfügen. Wenn dieser Container veröffentlicht wird, kann Ihre Anwendung je nach Sprache des Geräts des Nutzers zur Laufzeit lokalisierte Anzeigetexte anzeigen.

Wenn Ihr Standardcontainer Regeln benötigt, müssen Sie eine binäre Containerdatei als Standard container verwenden.

Weitere Informationen zum Konfigurieren von Regeln (Hilfe).

Binäre Standardcontainerdateien

Für Standardcontainer, die Regeln benötigen, sollte eine binäre Containerdatei anstelle einer Eigenschaftsliste oder JSON Datei als Standardcontainer verwendet werden. Binäre Container unterstützen die Bestimmung von Makrowerten zur Laufzeit mit Google Tag Manager-Regeln, Eigenschaftslisten oder JSON-Dateien jedoch nicht.

Binäre Containerdateien können über die Google Tag Manager-Weboberfläche heruntergeladen und dem Hauptbundle Ihrer Anwendung gemäß dieser Namenskonvention hinzugefügt werden: GTM-XXXX, wobei der Dateiname Ihre Container-ID darstellt.

Wenn sowohl eine Eigenschaftsliste und/oder eine JSON-Datei als auch eine binäre Containerdatei vorhanden sind, verwendet das SDK die binäre Containerdatei als Standardcontainer.

Funktionsaufruf-Makros verwenden

Funktionsaufruf-Makros sind Makros, die auf den Rückgabewert einer bestimmten Funktion in Ihrer Anwendung festgelegt sind. Funktionsaufruf-Makros können verwendet werden, um Laufzeitwerte in Ihre Google Tag Manager-Regeln einzubinden, z. B. um zur Laufzeit zu bestimmen, welcher Preis einem Nutzer basierend auf der konfigurierten Sprache und Währung eines Geräts angezeigt werden soll.

So konfigurieren Sie ein Funktionsaufruf-Makro:

  1. Definieren Sie das Funktionsaufruf-Makro in der Google Tag Manager-Weboberfläche. Argumente können optional als Schlüssel/Wert-Paare konfiguriert werden.
  2. Definieren Sie einen Handler, der das TAGFunctionCallMacroHandler Protokoll implementiert: 
    // 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. Registrieren Sie den Handler mit TAGContainer::registerFunctionCallMacroHandler:forMacro: und dem Funktionsnamen in der Google Tag Manager-Oberfläche angegebenen: 
    //
// 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

Funktionsaufruf-Tags verwenden

Mit Funktionsaufruf-Tags können vorab registrierte Funktionen ausgeführt werden, wenn ein Ereignis in die Datenschicht übertragen wird und die Tag-Regeln `true` ergebentrue.

So konfigurieren Sie ein Funktionsaufruf-Tag:

  1. Definieren Sie das Funktionsaufruf-Tag in der Google Tag Manager-Weboberfläche. Argumente können optional als Schlüssel/Wert-Paare konfiguriert werden.
  2. Implementieren Sie das TAGFunctionCallTagHandler-Protokoll: 
    //
// 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. Registrieren Sie den Handler für das Funktionsaufruf-Tag mit dem in der Google Tag Manager-Weboberfläche konfigurierten Tag-Namen: 
    //
// 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

Benutzerdefinierten Aktualisierungszeitraum festlegen

Das Google Tag Manager SDK versucht, einen neuen Container abzurufen, wenn der aktuelle Container älter als 12 Stunden ist. Wenn Sie einen benutzerdefinierten Aktualisierungszeitraum für den Container festlegen möchten, verwenden Sie NSTimer, wie im folgenden Beispiel:

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

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

Fehlerbehebung mit Logger

Das Google Tag Manager SDK gibt standardmäßig Fehler und Warnungen in Logs aus. Eine ausführlichere Protokollierung kann bei der Fehlerbehebung hilfreich sein. Sie können sie aktivieren, indem Sie einen eigenen Logger implementieren, wie in diesem Beispiel:

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

Alternativ können Sie die Logebene des vorhandenen Loggers mit TagManager::logger::setLogLevel, festlegen, wie in diesem Beispiel:

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