‫Google משתמשת בטכנולוגיית AI כדי לתרגם תוכן לשפה המועדפת עליך. בתרגומים כאלו עשויות להיות שגיאות.

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

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

מבוא

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

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

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

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

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

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

Google Mobile App Analytics
תג Custom Function Call (בקשה להפעלת פונקציה בהתאמה אישית)

לפני שתתחיל

לפני שמשתמשים במדריך הזה למתחילים, צריך:

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

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

תחילת העבודה

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

הוספת Google Tag Manager SDK לפרויקט
הגדרת ערכי ברירת מחדל למאגר התגים
פתיחת המאגר
קבלת ערכי הגדרה מהמאגר
העברת אירועים אל DataLayer
תצוגה מקדימה ופרסום של מאגר התגים

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) ולדגל המעקב שמופיעים ב-framework הזה באמצעות פקודות מאקרו של Google Tag Manager SDK, צריך גם לקשר את הספריות הנוספות האלה:

libAdIdAccess.a
AdSupport.framework

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

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

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

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

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

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

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

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

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

כתובות ה-URL של התצוגה המקדימה זמינות בחלון התצוגה המקדימה של ממשק האינטרנט של Tag Manager — **איור 1:** קבלת כתובת URL לתצוגה מקדימה מממשק האינטרנט של Tag Manager.

כדי להפעיל תצוגות מקדימות של מאגר תגים, צריך להוסיף קוד לקובץ ההטמעה של delegate האפליקציה ולהגדיר את סכימת כתובות ה-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 types של קובץ רשימת המאפיינים של האפליקציה:

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

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

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

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

הגדרה מתקדמת

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

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

ערכת ה-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`	שגיאת קלט/פלט מנעה את רענון המאגר.
`kTAGContainerCallbackRefreshFailureNoNetwork`	אין חיבור לרשת.
`kTAGContainerCallbackRefreshFailureNetworkError`	אירעה שגיאת רשת.
`kTAGContainerCallbackRefreshFailureServerError`	אירעה שגיאה בשרת.
`kTAGContainerCallbackRefreshFailureUnknownError`	אירעה שגיאה שלא ניתן לסווג.

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

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

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

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

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

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

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

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

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

מגדירים 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

רושמים את ה-handler באמצעות TAGContainer::registerFunctionCallMacroHandler:forMacro: ‎ ואת שם הפונקציה שצוין בממשק של 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.

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

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

מטמיעים את פרוטוקול 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

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

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

ערכת ה-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

‫Google Tag Manager SDK מדפיס שגיאות ואזהרות ביומנים כברירת מחדל. הפעלת רישום מפורט יותר ביומן יכולה לעזור בניפוי באגים, ואפשר לעשות זאת באמצעות הטמעה של 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];

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

מבוא

לפני שתתחיל

תחילת העבודה

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

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

3. פתיחת מאגר תגים

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

5. העברת ערכים ל-dataLayer

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

הגדרה מתקדמת

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

openContainerById:callback:

RefreshType

RefreshFailure

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

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

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

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

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

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

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

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