Erste Schritte mit Objective-C

In diesem Entwicklerhandbuch 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 Binärdateien 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 zur Laufzeit auch mithilfe von Regeln ausgewertet werden. Dadurch werden dynamische Konfigurationen wie die folgenden aktiviert:

  • Größe des Anzeigenbanners anhand der Bildschirmgröße bestimmen
  • UI-Elemente mithilfe von Sprache und Standort konfigurieren

Google Tag Manager ermöglicht auch die dynamische Implementierung von Tracking-Tags und -Pixeln in Anwendungen. Entwickler können wichtige Ereignisse in eine Datenschicht übertragen und dann 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 Funktion

Vorbereitung

Bevor Sie diesen Startleitfaden verwenden, benötigen Sie Folgendes:

Wenn Sie Google Tag Manager noch nicht kennen, sollten Sie sich in diesem Hilfeartikel über Container, Makros und Regeln informieren.

Erste Schritte

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

  1. Ihrem 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 an die Datenschicht übertragen
  6. Container in der Vorschau ansehen und veröffentlichen

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

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

Fügen Sie als Nächstes den verknüpften Bibliotheken Ihres Anwendungsziels Folgendes hinzu, falls sie noch nicht vorhanden sind:

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

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

  • libAdIdAccess.a
  • AdSupport.framework

2. Standard-Containerdatei zu Ihrem Projekt hinzufügen

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

So laden Sie ein standardmäßiges Container-Binärprogramm herunter und fügen es Ihrer Anwendung hinzu:

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

Als Standarddateiname sollte die Container-ID verwendet werden (z. B. GTM-1234). Entfernen Sie nach dem Herunterladen der Binärdatei das Versionssuffix aus dem Dateinamen, damit die korrekte Namenskonvention eingehalten wird.

Obwohl die Verwendung der Binärdatei empfohlen wird, wenn Ihr Container keine Regeln oder Tags enthält, können Sie auch eine einfache Property-Liste oder JSON-Datei verwenden. Die Datei sollte sich im Hauptpaket befinden und der folgenden Namenskonvention folgen: <Container_ID>.<plist|json>. Wenn die Container-ID beispielsweise GTM-1234 lautet, können Sie die Standardcontainerwerte in einer Attributlistendatei namens GTM-1234.plist angeben.

3. Container öffnen

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

Am einfachsten öffnen Sie einen Container unter iOS mit openContainerWithId:tagManager:openType:timeout:notifier:. 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 Methoden <type>ForKey: 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 DataLayer übertragen

Die DataLayer ist eine Karte, mit der Laufzeitinformationen zu Ihrer App wie Touch-Ereignisse oder Bildschirmaufrufe für Tag Manager-Makros und -Tags in einem Container verfügbar gemacht werden.

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

Ereignisse werden mit push: in 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

Auf der Weboberfläche können Sie jetzt Tags wie Google Analytics-Tags erstellen, die für jeden Bildschirmaufruf ausgelöst werden. Erstellen Sie dazu folgende Regel: ist gleich „openScreen“. Erstellen Sie ein Datenschicht-Makro, das auf den Schlüssel „screenName“ in der Datenschicht verweist, um den Bildschirmnamen an eines dieser Tags zu übergeben. Sie können auch ein Tag (z. B. ein Google Ads-Conversion-Pixel) erstellen, das nur bei bestimmten Bildschirmaufrufen ausgelöst wird. Dazu erstellen Sie eine Regel, die Folgendes umfasst: entspricht „openScreen“ und entspricht „ConfirmationScreen“.

6. Container in der 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 des Containerentwurfs anzeigen lassen.

Wenn Sie die Vorschau eines Containers aufrufen möchten, generieren Sie in der Google Tag Manager-Weboberfläche eine Vorschau-URL. Wählen Sie dazu die Version des Containers und dann Preview aus. Diese Vorschau-URL benötigen Sie später, da Sie sie später benötigen.

Vorschau-URLs stehen im Vorschaufenster der Tag Manager-Weboberfläche zur Verfügung.
Abbildung 1: Vorschau-URL über die Tag Manager-Weboberfläche abrufen

Um die Containervorschau zu aktivieren, müssen Sie der Implementierungsdatei für die App-Delegierung Code hinzufügen und das Vorschau-URL-Schema von Google Tag Manager in der Property-Liste Ihres Projekts definieren.

Fügen Sie der App-Delegate-Datei zuerst die folgenden fett formatierten Code-Snippets 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 als Nächstes die folgende URL-ID und das URL-Schema unter dem URL-Typenschlüssel der Attributdatei Ihrer Anwendung:

URL identifier: your.package_name
URL scheme: tagmanager.c.your.package.name
Registrieren Sie das Vorschau-URL-Schema des Tag Managers in der Eigenschaftsliste der Anwendung.
Abbildung 3: Vorschau-URL-Schema von Tag Manager zur Property-Liste Ihrer Anwendung hinzufügen

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

Wenn Sie bereit sind, die Werte Ihrer Konfigurationsentwürfe 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 basierend auf Laufzeitbedingungen mithilfe von Regeln auswählen, den Container manuell aktualisieren und zusätzliche Optionen zum Öffnen von Containern abrufen können. In den folgenden Abschnitten werden einige der am häufigsten verwendeten 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 niedrigste und flexibelste API zum Öffnen eines Containers. Sie wird sofort mit einem Standardcontainer zurückgegeben und lädt außerdem asynchron vom Laufwerk oder aus dem Netzwerk, wenn kein gespeicherter Container vorhanden ist oder wenn der gespeicherte Container nicht aktuell ist (> 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 Lebenszyklus-Callbacks aus, damit dein Code herausfinden kann, wann die Ladeanfrage beginnt, ob und warum er 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 anhand dieser Callbacks ermitteln, wann ein gespeicherter oder ein Netzwerkcontainer geladen wurde. Beachten Sie, dass Sie keinen gespeicherten Container 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:

Aktualisierungstyp

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

Aktualisierung fehlgeschlagen

WertBeschreibung
kTAGContainerCallbackRefreshFailureNoSavedContainer Es ist kein gespeicherter Container verfügbar.
kTAGContainerCallbackRefreshFailureIoError Ein E/A-Fehler hat das Aktualisieren des Containers verhindert.
kTAGContainerCallbackRefreshFailureNoNetwork Es ist keine Netzwerkverbindung verfügbar.
kTAGContainerCallbackRefreshFailureNetworkError Ein Netzwerkfehler ist aufgetreten.
kTAGContainerCallbackRefreshFailureServerError Auf dem Server ist ein Fehler aufgetreten.
kTAGContainerCallbackRefreshFailureUnknownError Es ist ein Fehler 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:.

Für jede dieser Methoden wird eine Aufzählung verwendet, die entweder einen nicht standardmäßigen oder einen neuen Container anfordert.

kTAGOpenTypePreferNonDefault wird für die meisten Anwendungen empfohlen und versucht, den ersten verfügbaren nicht standardmäßigen Container innerhalb eines bestimmten Zeitlimits über das Laufwerk oder das Netzwerk zurückzugeben, auch wenn dieser Container mehr als 12 Stunden alt ist. Wenn ein veralteter gespeicherter Container zurückgegeben wird, wird außerdem eine neue Netzwerkanfrage für einen neuen Container gesendet. Wenn Sie kTAGOpenTypePreferNonDefault verwenden, wird ein Standardcontainer zurückgegeben, wenn kein anderer Container verfügbar ist oder wenn das Zeitlimit überschritten wird.

kTAGOpenTypePreferFresh versucht, innerhalb des festgelegten Zeitlimits einen neuen Container von einem Laufwerk oder einem Netzwerk zurückzugeben. Er gibt einen gespeicherten Container zurück, wenn keine Netzwerkverbindung verfügbar ist und/oder das Zeitlimit überschritten wurde.

Wir raten davon ab, kTAGOpenTypePreferFresh an Orten zu verwenden, an denen eine längere Anfragezeit die Nutzerfreundlichkeit erheblich beeinträchtigen kann, z. B. mit UI-Flags oder Anzeigestrings. Sie können auch jederzeit TAGContainer::refresh verwenden, um eine Netzwerkcontaineranfrage zu erzwingen.

Bei beiden Methoden wird die Blockierung nicht blockiert. openContainerWithId:tagManager:openType:timeout: gibt ein TAGContainerFuture-Objekt zurück, dessen get-Methode eine TAGContainer zurückgibt, sobald sie geladen wurde (das wird aber bis dahin blockiert). Die Methode openContainerWithId:tagManager:openType:timeout:notifier: akzeptiert einen einzelnen Callback, der aufgerufen wird, wenn der Container verfügbar ist. Für beide Methoden gilt ein Standardzeitlimit von 2.0 Sekunden.

Makros zur Laufzeit mit Regeln auswerten

Container können zur Laufzeit Werte mithilfe von Regeln auswerten. Regeln können auf Kriterien wie der Gerätesprache, der Plattform oder einem anderen Makrowert basieren. Beispielsweise können Regeln 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:

Mit einer Regel werden Anzeigestrings basierend auf der Gerätesprache zur Laufzeit ausgewählt: Sprache ist gleich Diese Regel verwendet das vordefinierte Sprachmakro und einen zweistelligen ISO 639-1-Sprachcode.
Abbildung 1:Eine Regel hinzufügen, mit der ein Makro zur Werterfassung nur für Geräte aktiviert wird, die für die Verwendung der spanischen Sprache konfiguriert sind.

Sie können dann Makros für die Werterfassung für jede Sprache erstellen und diese Regel jedem Makro hinzufügen. Dazu fügen Sie den entsprechenden Sprachcode ein. Wenn dieser Container veröffentlicht wird, kann Ihre Anwendung je nach 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 (Hilfe)

Binäre Standard-Containerdateien

Standardcontainer, die Regeln benötigen, sollten als Standardcontainer eine binäre Containerdatei anstelle einer Attributlisten- oder JSON-Datei verwenden. Binärcontainer bieten Unterstützung für die Bestimmung von Makrowerten zur Laufzeit mit Google Tag Manager-Regeln. Dies gilt nicht für Attributlisten oder JSON-Dateien.

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

In Fällen, in denen eine Attributlisten- und/oder 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 angegebenen Funktion in Ihrer Anwendung festgelegt werden. Funktionsaufrufe-Makros können verwendet werden, um Laufzeitwerte in Ihre Google Tag Manager-Regeln einzubinden. Sie können beispielsweise zur Laufzeit bestimmen, welcher Preis Nutzern basierend auf der konfigurierten Sprache und Währung eines Geräts angezeigt wird.

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 in der Google Tag Manager-Oberfläche angegebenen Funktionsnamen.
    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

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 als true ausgewertet werden.

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 Protokoll 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. Registrieren Sie den Handler für den Funktionsaufruf-Tag mit dem Tag-Namen, der in der Google Tag Manager-Weboberfläche konfiguriert ist:
    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

Benutzerdefinierten Aktualisierungszeitraum festlegen

Das Google Tag Manager SDK versucht, einen neuen Container abzurufen, wenn das aktuelle Containeralter 12 Stunden überschreitet. Verwenden Sie zum Festlegen eines benutzerdefinierten Containeraktualisierungszeitraums 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. Die ausführlichere Protokollierung kann bei der Fehlerbehebung hilfreich sein und durch die Implementierung einer eigenen Logger wie in diesem Beispiel möglich sein:

// 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 LogLevel des vorhandenen Loggers mit TagManager::logger::setLogLevel festlegen. Beispiel: 

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