Startleitfaden für Objective-C

Hinweis:In diesem Leitfaden wird die alte Implementierung von Google Tag Manager in Android-Apps beschrieben. Neue Nutzer sollten Tag Manager und Firebase verwenden, um Google Tag Manager in ihren iOS-Apps zu implementieren.

In diesem Entwicklerleitfaden wird beschrieben, wie Sie Google Tag Manager in einer mobilen App implementieren.

Einführung

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

Dies ist nützlich, um Konfigurationswerte oder Flags in Ihrer Anwendung zu verwalten, die Sie möglicherweise in Zukunft ändern müssen. Dazu gehören:

• Verschiedene UI-Einstellungen und Anzeigestrings
• Größen, Standorte oder Anzeigentypen, die in Ihrer App ausgeliefert werden
• Spieleinstellungen

Konfigurationswerte können auch zur Laufzeit mithilfe von Regeln ausgewertet werden, um dynamische Konfigurationen wie die folgenden zu aktivieren:

• Verwendung der Bildschirmgröße zur Bestimmung der Größe von Anzeigenbannern
• UI-Elemente mit Sprache und Standort konfigurieren

Google Tag Manager ermöglicht außerdem die dynamische Implementierung von Tracking-Tags und -Pixeln in Anwendungen. Entwickler können wichtige Ereignisse in eine Datenschicht übertragen und später entscheiden, welche Tracking-Tags oder Pixel ausgelöst werden sollen. In Tag Manager werden derzeit die folgenden Tags unterstützt:

• Google Analytics für mobile Apps
• Aufruf-Tag für benutzerdefinierte Funktionen

Vorbereitung

Um diesen Startleitfaden verwenden zu können, benötigen Sie Folgendes:

• Ein Google Tag Manager-Konto
• Neues Tag Manager-Makro für Container und Werterfassung
• Eine mobile App für iOS, in der Google Tag Manager implementiert werden soll
• Das Google Analytics Services SDK, das die Tag Manager-Bibliothek enthält.

Wenn Sie Google Tag Manager zum ersten Mal verwenden, sollten Sie sich in der Hilfe über Container, Makros und Regeln informieren, bevor Sie mit dieser Anleitung fortfahren.

Erste Schritte

In diesem Abschnitt werden Entwickler durch einen typischen Tag Manager-Workflow geführt:

1. Einem Projekt das Google Tag Manager SDK hinzufügen
2. Standardwerte für Container festlegen
3. Container öffnen
4. Konfigurationswerte aus dem Container abrufen
5. Ereignisse in die DataLayer übertragen
6. Container als Vorschau ansehen und veröffentlichen

1. Ihrem Projekt das Google Tag Manager SDK hinzufügen

Bevor Sie das Google Tag Manager SDK verwenden können, müssen Sie Ihrem Projekt libGoogleAnalyticsServices.a und die GTM-Header-Dateien (Google Tag Manager) aus dem Verzeichnis Library des SDK-Pakets hinzufügen.

Als Nächstes fügen Sie den verknüpften Bibliotheken des Anwendungsziels Folgendes hinzu, falls diese noch nicht vorhanden sind:

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

Wenn Sie möchten, dass Ihre Anwendung auf den Identifier for Advertisers (IDFA) und das Tracking-Flag dieses Frameworks über die Google Tag Manager SDK-Makros zugreifen kann, müssen Sie auch diese zusätzlichen Bibliotheken verknüpfen:

• libAdIdAccess.a
• AdSupport.framework

Hinweis: Abhängig von Ihren Build-Einstellungen ist möglicherweise das Verknüpfungs-Flag -force_load /path/to/libAdIdAccess.a erforderlich.

2. Standardcontainerdatei zu Ihrem Projekt hinzufügen

Hinweis: Falls Sie Ihren Container noch nicht in der Weboberfläche von Google Tag Manager konfiguriert haben, kehren Sie anschließend zu diesem Schritt zurück.

Google Tag Manager verwendet bei der ersten Ausführung Ihrer Anwendung einen Standardcontainer. Der Standardcontainer wird so lange verwendet, bis die Anwendung einen neuen Container über das Netzwerk abrufen kann.

So laden Sie eine Standardbinärdatei für Container herunter und fügen sie zu Ihrer Anwendung hinzu:

1. Melden Sie sich auf der Weboberfläche von Google Tag Manager an.
2. Wählen Sie die Version des Containers aus, den Sie herunterladen möchten.
3. Klicken Sie auf die Schaltfläche Herunterladen, um die Containerbinärdatei abzurufen.
4. Fügen Sie die Binärdatei im Stammverzeichnis Ihres Projekts und in den 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 die korrekte Namenskonvention eingehalten wird.

Es wird zwar empfohlen, die Binärdatei zu verwenden. Wenn Ihr Container jedoch keine Regeln oder Tags enthält, können Sie stattdessen eine einfache Attributliste oder eine JSON-Datei verwenden. Die Datei sollte sich im Haupt-Bundle befinden und der Namenskonvention <Container_ID>.<plist|json> entsprechen. Lautet die Container-ID beispielsweise GTM-1234, können Sie die Standardcontainerwerte in einer Attributlistendatei namens GTM-1234.plist angeben.

Hinweis: Wenn im Haupt-Bundle sowohl eine Attributliste als auch ein JSON-Standardcontainer vorhanden sind, verwendet das SDK die Attributliste als Standardcontainer.

3. Container öffnen

Bevor Werte aus einem Container abgerufen werden können, muss die Anwendung den Container öffnen. Wenn Sie einen Container öffnen, wird er vom Laufwerk geladen (falls verfügbar) oder er wird beim Netzwerk angefordert (falls erforderlich).

Am einfachsten lassen sich Container unter iOS mit openContainerWithId:tagManager:openType:timeout:notifier: öffnen, wie im folgenden Beispiel gezeigt:

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

Hinweis: Wenn Ihre Anwendung von Konfigurationswerten des Containers abhängt, sollten Sie einen Ladebildschirm oder eine andere Zwischenansicht anzeigen, bis der Container geladen wurde. Eine Möglichkeit besteht darin, den Code zum Laden des Containers in den Root-Ansicht-Controller zu verschieben. Der Root-Ansicht-Controller kann eine modale Ansicht anzeigen, während der Container geladen wird.

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

Bei Anfragen mit einem nicht vorhandenen Schlüssel wird ein Standardwert zurückgegeben, 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 in die DataLayer übertragen

Ein DataLayer ist eine Karte, mit der Laufzeitinformationen zu Ihrer App, z. B. Touchereignisse oder Bildschirmaufrufe, für Tag Manager-Makros und -Tags in einem Container verfügbar sind.

Wenn Sie beispielsweise Informationen zu Bildschirmaufrufen in die DataLayer-Karte übertragen, können Sie Tags in der Tag Manager-Weboberfläche einrichten, um als Reaktion auf diese Bildschirmaufrufe Conversion-Pixel auszulösen und Aufrufe zu erfassen, ohne sie in Ihrer App hart codieren zu müssen.

Ereignisse werden mit push: an die DataLayer ü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 (wie Google Analytics-Tags) erstellen, die für jeden Bildschirmaufruf ausgelöst werden, indem Sie die folgende Regel erstellen: ist gleich "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 Bildschirmaufrufe ausgelöst wird. Dazu erstellen Sie eine Regel, bei der gleich "openScreen" && ist gleich "ConfirmationScreen" ist.

Hinweis: DataLayer-Ereigniswerte und ‐schlüssel sollten so konsistent wie möglich verwendet werden, damit in diesem Beispiel für alle Bildschirmaufrufe „openScreen“ als Ereigniswert und „screenName“ als Bildschirmnamensschlüssel verwendet wird. Dies macht den Zugriff auf den DataLayer und das Erstellen zusätzlicher Tags in Zukunft so einfach wie möglich.

6. Container in der Vorschau ansehen und veröffentlichen

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

Wenn Sie sich einen Container als Vorschau ansehen möchten, können Sie auf der Weboberfläche von Google Tag Manager eine Vorschau-URL erstellen. Wählen Sie dazu die gewünschte Containerversion und dann Preview aus. Behalten Sie diese Vorschau-URL bei, da Sie sie in späteren Schritten benötigen.

Abbildung 1 : Vorschau-URL über die Tag Manager-Weboberfläche abrufen

Um die Containervorschau zu aktivieren, müssen Sie Code in Ihre App-Delegat-Implementierungsdatei einfügen und das Google Tag Manager-Vorschau-URL-Schema in der Attributliste Ihres Projekts definieren.

Fügen Sie zuerst die folgenden fett formatierten Code-Snippets in Ihre App-Delegatdatei ein:

@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 als Nächstes die folgende URL-ID und das URL-Schema unter dem URL-Typenschlüssel der Attributlistendatei Ihrer Anwendung:

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

Abbildung 3 : Tag Manager-Vorschau-URL-Schema zur Property-Listendatei Ihrer App hinzufügen

Hinweis: your.package.name muss mit dem Namen der App übereinstimmen, die zum Generieren der Vorschau-URL verwendet wurde (Abbildung 1).

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

Wenn Sie bereit sind, die Entwurfskonfigurationswerte für Ihre Anwendung verfügbar zu machen, veröffentlichen Sie den Container.

Erweiterte Konfiguration

Google Tag Manager für Mobilgeräte bietet eine Reihe erweiterter Konfigurationsoptionen, mit denen Sie Werte anhand von 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 gängigsten 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 unterste und flexibelste API zum Öffnen eines Containers. Es wird sofort mit einem Standardcontainer zurückgegeben und ein Container auch asynchron vom Laufwerk oder aus dem Netzwerk geladen, wenn kein gespeicherter Container vorhanden ist oder der gespeicherte Container nicht aktuell ist (mehr als 12 Stunden alt).

@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 gesamten Ladevorgangs gibt openContainerById:callback: mehrere Lebenszyklus-Callbacks aus, damit Ihr Code herausfinden kann, wann die Ladeanfrage beginnt, ob und warum sie fehlschlägt oder erfolgreich ist und ob der Container letztendlich vom Laufwerk oder Netzwerk geladen wurde.

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

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

RefreshType

Wert	Beschreibung
kTAGContainerCallbackRefreshTypeSaved	Mit der Aktualisierungsanfrage wird ein lokal gespeicherter Container geladen.
kTAGContainerCallbackRefreshTypeNetwork	Mit der Aktualisierungsanfrage wird ein Container über das Netzwerk geladen.

RefreshFailure

Wert	Beschreibung
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, der nicht kategorisiert werden kann, ist aufgetreten.

Methoden zum Öffnen nicht standardmäßiger und aktueller Container

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

Bei jeder dieser Methoden wird eine Aufzählung verwendet, um entweder einen nicht standardmäßigen oder einen neuen Container anzufordern.

kTAGOpenTypePreferNonDefault wird für die meisten Anwendungen empfohlen und versucht, den ersten verfügbaren nicht standardmäßigen Container innerhalb eines bestimmten Zeitlimits zurückzugeben, entweder vom Laufwerk oder vom Netzwerk, auch wenn dieser Container älter als 12 Stunden ist. Wenn ein veralteter gespeicherter Container zurückgegeben wird, wird ebenfalls eine asynchrone Netzwerkanfrage für einen neuen gesendet. 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 einem Laufwerk oder 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 Orten zu verwenden, an denen eine längere Anfragezeit die Nutzerfreundlichkeit merklich beeinträchtigen kann, z. B. bei UI-Flags oder Anzeigestrings. Sie können auch jederzeit TAGContainer::refresh verwenden, um eine Netzwerkcontaineranfrage zu erzwingen.

Beide 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 (aber das blockiert 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 standardmäßig ein Zeitlimit von 2.0 Sekunden.

Makros zur Laufzeit mithilfe von Regeln bewerten

Container können Werte zur Laufzeit mithilfe von Regeln auswerten. Regeln können auf Kriterien wie Gerätesprache, Plattform oder einem anderen Makrowert basieren. Regeln können beispielsweise verwendet werden, um einen lokalisierten Anzeigestring basierend auf der Sprache des Geräts zur Laufzeit auszuwählen. Dies kann mit der folgenden Regel konfiguriert werden:

Abbildung 1: Eine Regel hinzufügen, um ein Werterfassungsmakro nur für Geräte zu aktivieren, die für die Verwendung der spanischen Sprache konfiguriert sind

Sie können dann Makros zur Werterfassung 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 der Sprache des Nutzergeräts zur Laufzeit lokalisierte Anzeigestrings anzeigen.

Wenn für Ihren Standardcontainer Regeln erforderlich sind, müssen Sie eine binäre Containerdatei als Standardcontainer verwenden.

Weitere Informationen zum Konfigurieren von Regeln (Analytics-Hilfe).

Binäre Standard-Containerdateien

Standardcontainer, für die Regeln erforderlich sind, sollten als Standardcontainer eine binäre Containerdatei anstelle einer Attributlistendatei oder einer JSON-Datei verwenden. Binäre Container bieten Unterstützung zum Ermitteln von Makrowerten zur Laufzeit mit Google Tag Manager-Regeln, im Gegensatz zu Attributlisten oder JSON-Dateien.

Binär-Containerdateien können über die Weboberfläche von Google Tag Manager heruntergeladen werden. Sie müssen dem Hauptanwendungs-Bundle gemäß der folgenden Namenskonvention hinzugefügt werden: GTM-XXXX, wobei der Dateiname die Container-ID darstellt.

Wenn eine Attributlistendatei und/oder eine JSON-Datei sowie 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 gesetzt werden. Funktionsaufruf-Makros können verwendet werden, um Laufzeitwerte in Ihre Google Tag Manager-Regeln zu integrieren. So lässt sich beispielsweise anhand der konfigurierten Sprache und Währung eines Geräts ermitteln, welcher Preis einem Nutzer zur Laufzeit angezeigt werden soll.

So konfigurieren Sie ein Funktionsaufrufmakro:

1. Definieren Sie das Funktionsaufruf-Makro auf der Weboberfläche des Google Tag Managers. 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, der auf der Google Tag Manager-Oberfläche angegeben wurde:

//
// 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 vorregistrierte Funktionen ausgeführt werden, wenn ein Ereignis in die Datenschicht übertragen wird und die Tag-Regeln true ergeben.

So konfigurieren Sie ein Funktionsaufruf-Tag:

1. Definieren Sie das Funktionsaufruf-Tag auf 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 Tag-Handler für Funktionsaufrufe mit dem Tag-Namen, der in der Google Tag Manager-Weboberfläche konfiguriert wurde:

//
// 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 das aktuelle Containeralter 12 Stunden überschreitet. Verwenden Sie NSTimer wie im folgenden Beispiel, um einen benutzerdefinierten Aktualisierungszeitraum für Container festzulegen:

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

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

Debugging mit Logger

Das Google Tag Manager SDK gibt standardmäßig Fehler und Warnungen in Logs aus. Das Aktivieren eines ausführlicheren Loggings kann für die Fehlerbehebung hilfreich sein und ist durch die Implementierung eines eigenen Logger wie in diesem Beispiel möglich:

// 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 den LogLevel des vorhandenen Loggers mithilfe von TagManager::logger::setLogLevel wie in diesem Beispiel festlegen:

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