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

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

מבוא

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

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

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

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

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

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

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

לפני שתתחיל

כדי להשתמש במדריך לתחילת העבודה, אתם צריכים:

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

תחילת העבודה

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

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

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

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

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

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

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

  • libAdIdAccess.a
  • AdSupport.framework

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

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

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

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

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

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

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.

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

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

// Retrieving a configuration value from a Tag Manager Container.

MyAppDelegate *appDelegate = (MyAppDelegate *)[[UIApplication sharedApplication] delegate];
TAGContainer *container = appDelegate.container;

// Get the configuration value by key.
NSString *title = [container stringForKey:@"title_string"];

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

// 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 כדי להפעיל פיקסלים של המרות. ומעקב אחרי שיחות בתגובה לצפיות האלה במסך, בלי שתצטרכו לקודד אותם באפליקציה.

האירועים מועברים ל-DataLayer באמצעות 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) כדי להפעיל כל צפייה במסך על ידי יצירת הכלל הבא: שווה ל-openScreen. כדי להעביר את שם המסך לאחד מהתגים האלה, ליצור מאקרו של שכבת נתונים שמפנה ל-'screenName' בשכבת הנתונים. אפשר גם ליצור תג (כמו פיקסל המרה של Google Ads) שיופעל רק עבור צפיות מסוימות במסך, על ידי יצירת כלל שבו שווה ל-openScreen &amp;&amp; שווה ל-"ConfirmationScreen".

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 ואת סכימת כתובת ה-URL הבאים במסגרת מפתח של סוגי כתובות URL בקובץ רשימת המאפיינים של האפליקציה:

URL identifier: your.package_name
URL scheme: tagmanager.c.your.package.name
רישום סכמת כתובת ה-URL של התצוגה המקדימה של Tag Manager באפליקציה קובץ רשימת הנכסים.
איור 3: הוספת סכמת כתובת ה-URL לתצוגה מקדימה של Tag Manager לקובץ רשימת המאפיינים של האפליקציה.

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

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

תצורה מתקדמת

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) במחזור החיים, כדי שהקוד יוכל לגלות מתי הטעינה מתחילה, האם היא נכשלת או מצליחה, והאם הקונטיינר נטען בסופו של דבר מהדיסק או מהרשת.

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

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

RefreshType

ערךתיאור
kTAGContainerCallbackRefreshTypeSaved בבקשת הרענון נטען מאגר תגים שנשמר באופן מקומי.
kTAGContainerCallbackRefreshTypeNetwork בקשת הרענון טוענת קונטיינר דרך הרשת.

RefreshFailure

ערךתיאור
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, שה-method get שלו מחזירה TAGContainer ברגע הטעינה (אבל היא תיחסם עד אז). השיטה openContainerWithId:tagManager:openType:timeout:notifier: מבצעת קריאה חוזרת אחת, קוראים לפונקציה כשהקונטיינר זמין. לשתי השיטות יש כברירת מחדל פרק זמן הקצוב לתפוגה של 2.0 שניות.

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

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

כלל משמש לבחירת מחרוזות תצוגה על סמך שפת המכשיר ב- סביבת זמן ריצה: השפה שווה es. הכלל הזה משתמש בשפה המוגדרת מראש מאקרו וקוד שפה בן שני תווים לפי תקן ISO 639-1.
איור 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::registerFunctionCallMacroHandler:forMacro: ושם הפונקציה שצוין בממשק של Google Tag Manager:
    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

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

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

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

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

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

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

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

ערכת ה-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 של ה-Logger הקיים באמצעות 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];