המדריך לתחילת העבודה עבור מטרה ג'

הערה: במדריך הזה מתואר ההטמעה הישנה של Google Tag Manager באפליקציות ל-Android. משתמשים חדשים צריכים להשתמש ב- Tag Manager + Firebase כדי להטמיע את Google Tag Manager באפליקציות שלהם ל-iOS.

במדריך למפתחים מוסבר איך להטמיע את Google Tag Manager באפליקציה לנייד.

מבוא

Google Tag Manager מאפשר למפתחים לשנות את ערכי התצורה באפליקציות שלהם לנייד באמצעות הממשק של Google Tag Manager, בלי שיצטרכו ליצור מחדש קבצים בינאריים של אפליקציות ולשלוח אותם מחדש לזירות מסחר של אפליקציות.

כך תוכלו לנהל את ערכי ההגדרות והדגלים באפליקציה שאולי תצטרכו לשנות בעתיד, כולל:

• הגדרות שונות של ממשק המשתמש ומחרוזות תצוגה
• גדלים, מיקומים או סוגים של מודעות שהוצגו באפליקציה שלכם
• הגדרות של משחקים

ניתן גם להעריך את ערכי התצורה בזמן ריצה באמצעות כללים, ולהפעיל הגדרות דינמיות כמו:

• שימוש בגודל המסך לקביעת גודל הבאנר של המודעה
• שימוש בשפה ובמיקום להגדרת רכיבים בממשק המשתמש

Google TagManager גם מאפשר הטמעה דינמית של פיקסלים ותגים למעקב באפליקציות. מפתחים יכולים לדחוף אירועים חשובים לשכבת נתונים ולהחליט מאוחר יותר אילו תגי מעקב או פיקסלים להפעיל. TagManager תומך כרגע בתגים הבאים:

• Google Analytics לאפליקציות לנייד
• תג קריאה לפונקציה מותאמת אישית

לפני שתתחיל

לפני שמשתמשים במדריך לתחילת העבודה, תזדקקו לדברים הבאים:

• חשבון Google Tag Manager
• פקודת מאקרו חדשה של אוסף ערכים ומאגרי תגים ב-Tag Manager
• אפליקציה לנייד עבור iOS שבה אפשר להטמיע את Google Tag Manager
• ערכת ה-SDK ל-Google Analytics Services, שמכילה את ספריית Tag Manager.

אם עדיין לא השתמשת ב-Google Tag Manager, מומלץ לעיין במידע נוסף על מאגרי תגים, פקודות מאקרו וכללים (מרכז העזרה) לפני המשך המדריך.

תחילת העבודה

בקטע הזה נסביר למפתחים איך לבצע את תהליך העבודה האופייני של Tag Manager:

1. הוספת ה-SDK של Google Tag Manager לפרויקט
2. הגדרת ערכי ברירת מחדל במאגר התגים
3. פתיחת מאגר התגים
4. קבלת ערכי תצורה מהמאגר
5. דחיפת אירועים ל-DataLayer
6. הצגת תצוגה מקדימה של מאגר התגים ופרסום

1. הוספת Google Tag Manager SDK לפרויקט

לפני השימוש ב-SDK של Google Tag Manager, צריך להוסיף לפרויקט את קובצי הכותרת של libGoogleAnalyticsServices.a ואת קובצי הכותרת של Google Tag Manager (GTM) מהספרייה Library של חבילת ה-SDK.

לאחר מכן, צריך להוסיף את הספריות הבאות לספריות המקושרות של יעד האפליקציה, אם הן עדיין לא נמצאות:

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

אם ברצונך שהאפליקציה שלך תיגש למזהה עבור מפרסמים (IDFA) ולסימון המעקב שמסופק על ידי המסגרת הזו באמצעות פקודות המאקרו של ה-SDK של Google Tag Manager, עליך לקשר גם את הספריות הנוספות הבאות:

• libAdIdAccess.a
• AdSupport.framework

הערה: בהתאם להגדרות ה-build, יכול להיות שיהיה צורך בסימון המקשר -force_load /path/to/libAdIdAccess.a.

2. הוספת קובץ קונטיינר שמוגדר כברירת מחדל לפרויקט

הערה: אם עדיין לא הגדרתם את מאגר התגים בממשק האינטרנט של Google Tag Manager, חזרו לשלב הזה אחרי שתסיימו.

מנהל התגים של Google משתמש במאגר ברירת מחדל בהרצה הראשונה של האפליקציה. המערכת תשתמש במאגר התגים שמוגדר כברירת מחדל עד שהאפליקציה תוכל לאחזר מאגר נתונים חדש ברשת.

כדי להוריד ולהוסיף לאפליקציה שלכם קובץ בינארי של מאגר תגים המוגדר כברירת מחדל, בצעו את השלבים הבאים:

1. נכנסים לממשק האינטרנט של Google Tag Manager.
2. בוחרים את הגרסה של מאגר התגים שרוצים להוריד.
3. לוחצים על הלחצן הורדה כדי לאחזר את קובץ הבינארי של הקונטיינר.
4. מוסיפים את הקובץ הבינארי לספריית הבסיס של הפרויקט ולתיקייה 'Supporting Files' בפרויקט.

שם הקובץ שמוגדר כברירת מחדל צריך להיות מזהה מאגר התגים (לדוגמה, GTM-1234). לאחר הורדת הקובץ הבינארי, חשוב להסיר את סיומת הגרסה משם הקובץ כדי לוודא שהשם תואם למוסכמות מתן השמות הנכונות.

מומלץ להשתמש בקובץ הבינארי, אבל אם הקונטיינר לא מכיל כללים או תגים, אפשר להשתמש במקום זאת ברשימת נכסים פשוטה או בקובץ JSON. הקובץ צריך להיות ממוקם בחבילה הראשית ועליו להתאים למוסכמת מתן השמות הבאה: <Container_ID>.<plist|json>. לדוגמה, אם מזהה המאגר הוא GTM-1234, תוכלו לציין את ערכי ברירת המחדל של המאגר בקובץ רשימת נכסים שנקרא GTM-1234.plist.

הערה: אם בחבילה הראשית קיימים גם רשימת נכסים וגם קונטיינר ברירת המחדל של JSON, ה-SDK ישתמש ברשימת הנכסים כמאגר ברירת המחדל.

3. פתיחת קונטיינר

לפני שמאחזרים ערכים מקונטיינר, האפליקציה צריכה לפתוח את הקונטיינר. פתיחת קונטיינר תטען אותו מהדיסק (אם זמין), או תבקש אותו מהרשת (אם יש צורך).

הדרך הקלה ביותר לפתוח קונטיינר ב-iOS היא באמצעות openContainerWithId:tagManager:openType:timeout:notifier:, כמו בדוגמה הבאה:

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

הערה: אם האפליקציה שלכם תלויה בערכי ההגדרה של הקונטיינר, עליכם להציג מסך פתיחה או תצוגת ביניים אחרת עד שהמאגר ייטען. אחת הדרכים לעשות זאת היא להעביר את קוד הטעינה של הקונטיינר אל הבקר של תצוגת הבסיס. בקר התצוגה ברמה הבסיסית (root) יכול להציג תצוגה מודלית בזמן שהמאגר נטען.

4. קבלת ערכי תצורה מהמאגר

כשהמאגר פתוח, אפשר לאחזר את ערכי התצורה באמצעות <type>ForKey: method:

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

בקשות שנשלחות עם מפתח שלא קיים יחזירו ערך ברירת מחדל שמתאים לסוג המבוקש:

// 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. דחיפת ערכים לשכבת הנתונים

DataLayer היא מפה שמאפשרת לקבל מידע על זמן ריצה לגבי האפליקציה, כמו אירועי מגע או צפיות במסך, כזמינות לפקודות מאקרו ותגים של Tag Manager בקונטיינר.

לדוגמה, על ידי דחיפת מידע על צפיות במסך למפה של DataLayer, אפשר להגדיר תגים בממשק האינטרנט של Tag Manager כדי להפעיל פיקסלים של המרות ולמעקב אחרי קריאות למעקב בתגובה לאותן צפיות במסך, בלי לקודד אותם בתוך האפליקציה.

אירועים נדחפים לשכבת הנתונים באמצעות 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

בממשק האינטרנט אפשר ליצור עכשיו תגים (כמו תגים של Google Analytics) שיופעלו לכל צפייה במסך באמצעות יצירת הכלל הבא: equals "openScreen". כדי להעביר את שם המסך לאחד מהתגים האלה, צריך ליצור מאקרו של שכבת נתונים שמפנה למפתח "screenName" בשכבת הנתונים. אפשר גם ליצור תג (כמו פיקסל המרה של Google Ads) שיפעל רק עבור צפיות מסוימות במסך, על ידי יצירת כלל שבו שווה ל-"openScreen" && שווה "ConfirmationScreen".

הערה: כדאי להשתמש באופן עקבי ככל האפשר בערכים ובמפתחות של אירועים DataLayer כך הגישה ל-DataLayer ויצירת תגים נוספים בעתיד יהיו פשוטים ככל האפשר.

6. תצוגה מקדימה ופרסום של כלי קיבול

ערכי המאקרו יתאימו תמיד לגרסה הנוכחית שפורסמה. לפני שתפרסמו את הגרסה האחרונה של מאגר, תוכלו לראות תצוגה מקדימה של טיוטת מאגר התגים.

כדי להציג תצוגה מקדימה של מאגר, יוצרים כתובת URL לתצוגה מקדימה בממשק האינטרנט של Google Tag Manager. לשם כך, בוחרים את הגרסה של מאגר התגים שרוצים להציג בתצוגה מקדימה, ולוחצים על Preview. הישארו עם כתובת ה-URL של התצוגה המקדימה, כי תצטרכו אותה בשלבים הבאים.

איור 1: קבלת כתובת URL של תצוגה מקדימה מממשק האינטרנט של Tag Manager.

כדי להפעיל תצוגות מקדימות של מאגרי תגים, צריך להוסיף קוד לקובץ ההטמעה של הקצאת הרשאות הגישה, ולהגדיר את סכימת כתובת ה-URL של התצוגה המקדימה של Google Tag Manager ברשימת הנכסים של הפרויקט.

תחילה, צריך להוסיף את קטעי הקוד המודגשים הבאים לקובץ הקצאת ההרשאות:

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

לאחר מכן, רשום את מזהה כתובת האתר ואת סכימת כתובת האתר הבאים, תחת המפתח של סוגי כתובות האתר של קובץ רשימת המאפיינים של האפליקציה:

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

איור 3: הוספת סכמת כתובת ה-URL של התצוגה המקדימה של Tag Manager לקובץ רשימת המאפיינים של האפליקציה.

הערה: your.package.name צריך להתאים לשם האפליקציה ששימשה ליצירת כתובת ה-URL של התצוגה המקדימה (איור 1).

פותחים את הקישור באמולטור או במכשיר פיזי כדי להציג תצוגה מקדימה של מאגר הטיוטה באפליקציה.

כשהערכים של הגדרת הטיוטה יהיו זמינים לאפליקציה שלכם, עליכם לפרסם את מאגר התגים.

תצורה מתקדמת

ב-Google Tag Manager לנייד יש כמה אפשרויות הגדרה מתקדמות שמאפשרות לבחור ערכים בהתאם לתנאים בזמן הריצה באמצעות כללים, לרענן את המאגר באופן ידני ולקבל אפשרויות נוספות לפתיחת קונטיינרים. בקטעים הבאים מתוארות כמה מהגדרות ההגדרות המתקדמות הנפוצות ביותר.

אפשרויות מתקדמות לפתיחת קונטיינרים

ב-SDK של Google Tag Manager יש כמה שיטות לפתיחת קונטיינרים שיכולים לתת לכם יותר שליטה בתהליך הטעינה:

openContainerById:callback:

openContainerById:callback: הוא הרמה הנמוכה ביותר וה-API הגמיש ביותר לפתיחת קונטיינר. הוא מוחזר באופן מיידי עם קונטיינר ברירת מחדל, וגם טוען קונטיינר מהדיסק או מהרשת באופן אסינכרוני אם לא קיים קונטיינר שמור, או אם הקונטיינר שנשמר לא עדכני (לפני יותר מ-12 שעות).

@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

במהלך הטעינה, מערכת openContainerById:callback: מנפיקה כמה קריאות חוזרות (callback) במחזור החיים, כדי שהקוד יוכל לגלות מתי בקשת הטעינה מתחילה, אם היא נכשלת או מצליחה, ואם הקונטיינר נטען בסופו של דבר מהדיסק או מהרשת.

תצטרכו להשתמש בקריאות החוזרות (callback) האלה כדי לדעת מתי נטענו קונטיינרים שמורים או מאגרי רשת, אלא אם האפליקציה שלכם יכולה להשתמש בערכי ברירת המחדל. שימו לב שלא תוכלו לטעון מאגר שמור או מאגר תגים של רשת אם זו הפעם הראשונה שהאפליקציה מופעלת ואין חיבור לרשת.

openContainerById:callback: מעביר את הערכים הבאים של enum כארגומנטים לקריאה החוזרת (callback):

RefreshType

Value	התיאור
kTAGContainerCallbackRefreshTypeSaved	במסגרת הבקשה לרענון, המערכת טוענת מאגר נתונים ששמור באופן מקומי.
kTAGContainerCallbackRefreshTypeNetwork	במסגרת הבקשה לרענון, המערכת טוענת מאגר תגים ברשת.

RefreshFailure

Value	התיאור
kTAGContainerCallbackRefreshFailureNoSavedContainer	אין אף מאגר שמור זמין.
kTAGContainerCallbackRefreshFailureIoError	שגיאה של קלט/פלט (I/O) מנעה רענון של המכל.
kTAGContainerCallbackRefreshFailureNoNetwork	אין חיבור רשת זמין.
kTAGContainerCallbackRefreshFailureNetworkError	אירעה שגיאת רשת.
kTAGContainerCallbackRefreshFailureServerError	אירעה שגיאה בשרת.
kTAGContainerCallbackRefreshFailureUnknownError	אירעה שגיאה שלא ניתן לסווג.

שיטות לפתיחת קונטיינרים חדשים ולא ברירת מחדל

השדה TAGContainerOpener כולל את הטווח openContainerById:callback: ומספק שתי שיטות לפתיחת קונטיינרים: openContainerWithId:tagManager:openType:timeout:notifier: ו-openContainerWithId:tagManager:openType:timeout:.

בכל אחת מהשיטות האלה מתבצע ספירה שמבקשת קונטיינר שאינו ברירת המחדל או קונטיינר טרי.

מומלץ להשתמש ב-kTAGOpenTypePreferNonDefault לרוב האפליקציות, והוא ינסה להחזיר את הקונטיינר הזמין הראשון שלא מוגדר כברירת מחדל בפרק זמן נתון, מהדיסק או מהרשת, גם אם הוא נוצר לפני יותר מ-12 שעות. אם הוא מחזיר קונטיינר שמור לא פעיל, הוא שולח גם בקשת רשת אסינכרונית עבור מאגר חדש. כשמשתמשים ב-kTAGOpenTypePreferNonDefault, מוחזר קונטיינר שמוגדר כברירת מחדל אם אין קונטיינרים אחרים זמינים, או אם חורגים מהזמן הקצוב לתפוגה.

kTAGOpenTypePreferFresh מנסה להחזיר קונטיינר חדש מהדיסק או מהרשת במהלך הזמן הקצוב לתפוגה. הפונקציה מחזירה קונטיינר שמור אם החיבור לרשת לא זמין ו/או אם יש חריגה מהזמן הקצוב לתפוגה.

לא מומלץ להשתמש ב-kTAGOpenTypePreferFresh במקומות שבהם זמן בקשה ארוך יותר עלול להשפיע באופן משמעותי על חוויית המשתמש, למשל בדגלים של ממשק המשתמש או במחרוזות תצוגה. אפשר גם להשתמש ב-TAGContainer::refresh בכל שלב כדי לאלץ בקשה לקונטיינר של הרשת.

שתי שיטות הנוחות האלה לא חוסמות. openContainerWithId:tagManager:openType:timeout: מחזיר אובייקט TAGContainerFuture, שהשיטה get שלו מחזירה TAGContainer מיד אחרי הטעינה (אבל הוא ייחסם עד אז). השיטה openContainerWithId:tagManager:openType:timeout:notifier: משתמשת בקריאה חוזרת (callback) יחידה, שנקראת כשהמאגר זמין. בשתי השיטות, הזמן הקצוב לתפוגה שמוגדר כברירת מחדל הוא 2.0 שניות.

הערכת פקודות מאקרו בזמן ריצה באמצעות כללים

קונטיינרים יכולים להעריך ערכים בזמן ריצה באמצעות כללים. הכללים יכולים להתבסס על קריטריונים כמו שפת המכשיר, הפלטפורמה או כל ערך מאקרו אחר. לדוגמה, אפשר להשתמש בכללים כדי לבחור מחרוזת תצוגה מותאמת לשוק המקומי בהתאם לשפה של המכשיר בזמן הריצה. אפשר להגדיר זאת באמצעות הכלל הבא:

איור 1: הוספת כלל להפעלת מאקרו של אוסף ערכים רק עבור מכשירים שהוגדרו להשתמש בשפה הספרדית.

לאחר מכן תוכלו ליצור פקודות מאקרו לאיסוף ערכים לכל שפה, ולהוסיף את הכלל הזה לכל מאקרו, ולהוסיף את קוד השפה המתאים. כשהמאגר הזה יפורסם, האפליקציה תוכל להציג מחרוזות תצוגה שהותאמו לשוק המקומי, בהתאם לשפה במכשיר של המשתמש בזמן הריצה.

שימו לב שאם תגדירו כללים לקונטיינר שהגדרתם כברירת מחדל, תצטרכו להשתמש בקובץ קונטיינר בינארי בתור מאגר ברירת המחדל.

מידע נוסף על הגדרת כללים (מרכז העזרה)

קובצי מאגר תגים בינאריים שמוגדרים כברירת מחדל

קונטיינרים שמוגדרים כברירת מחדל ושצריכים להשתמש בכללים צריכים להשתמש בקובץ קונטיינר בינארי במקום בקובץ רשימת נכסים או קובץ JSON בתור המאגר שמוגדר כברירת מחדל. קונטיינרים בינאריים תומכים בקביעת ערכי מאקרו בזמן ריצה באמצעות הכללים של Google Tag Manager, ואילו רשימת הנכסים או קובצי JSON לא תומכת בהם.

אפשר להוריד קובצי קונטיינרים בינאריים מממשק האינטרנט של Google Tag Manager, ולהוסיף אותם לחבילת האפליקציות הראשית בהתאם למוסכמות מתן השמות הזו: GTM-XXXX, כאשר שם הקובץ מייצג את מזהה הקונטיינר.

במקרים שבהם יש קובץ של רשימת נכסים ו/או קובץ JSON וגם קובץ קונטיינר בינארי, ה-SDK ישתמש בקובץ הקונטיינר הבינארי כמאגר ברירת המחדל.

שימוש בפקודות מאקרו של שיחות פונקציה

פקודות מאקרו של שיחות פונקציה הן פקודות מאקרו שמוגדרות לערך המוחזר של פונקציה מסוימת באפליקציה שלכם. אפשר להשתמש בפקודות מאקרו של שיחות פונקציה כדי לשלב ערכי זמן ריצה בכללים של Google Tag Manager, למשל כדי לקבוע בזמן הריצה איזה מחיר להציג למשתמש על סמך השפה והמטבע שהוגדרו במכשיר.

כדי להגדיר מאקרו של קריאה לפונקציה:

1. מגדירים את המאקרו של הפעלת הפונקציה בממשק האינטרנט של Google Tag Manager. אפשר להגדיר ארגומנטים כצמדי מפתח/ערך.
2. מגדירים handler שמטמיע את הפרוטוקול 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. רשום את ה-handler באמצעות TAGContainer::registerFunctionCallמאקרוHandler:for ביחד: ואת שם הפונקציה שמצוין בממשק של Google Tag Manager:

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

שימוש בתגי קריאה של פונקציות

תגי קריאה לפונקציה מאפשרים ביצוע של פונקציות שנרשמו מראש בכל פעם שאירוע מועבר לשכבת הנתונים, וכללי התג מבצעים את ההערכה ל-true.

כדי להגדיר תג קריאה לפונקציה:

1. יש להגדיר את תג הקריאה לפונקציה בממשק האינטרנט של Google Tag Manager. אפשר להגדיר ארגומנטים כצמדי מפתח/ערך.
2. מטמיעים את הפרוטוקול 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. רושמים את הגורם המטפל בתג קריאה לפונקציה באמצעות שם התג שהוגדר בממשק האינטרנט של Google Tag Manager:

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

הגדרת תקופת רענון מותאמת אישית

אם גיל המאגר הנוכחי חורג מ-12 שעות, מערכת ה-SDK של Google Tag Manager תנסה לאחזר מאגר תגים חדש. כדי להגדיר תקופת רענון לקונטיינרים בהתאמה אישית, משתמשים ב-NSTimer כמו בדוגמה הבאה:

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

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

ניפוי באגים באמצעות יומן

כברירת מחדל, ה-SDK של Google Tag Manager מדפיס שגיאות ואזהרות ביומנים. הפעלה של רישום מפורט יותר ביומן יכולה להועיל לניפוי באגים, ואפשר גם להטמיע Logger משלכם, כמו בדוגמה הבאה:

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

לחלופין, אפשר להגדיר את ה-LogLevel של יומן הרישום הקיים באמצעות TagManager::logger::setLogLevel, כמו בדוגמה הבאה:

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