ऑब्जेक्टिव-सी के लिए शुरुआती निर्देश

इस डेवलपर गाइड में, मोबाइल ऐप्लिकेशन में Google Tag Manager को लागू करने का तरीका बताया गया है.

परिचय

Google Tag Manager की मदद से डेवलपर, अपने मोबाइल ऐप्लिकेशन में कॉन्फ़िगरेशन की वैल्यू बदल सकते हैं. इसके लिए, उन्हें Google Tag Manager इंटरफ़ेस का इस्तेमाल करना होगा. साथ ही, उन्हें ऐप्लिकेशन मार्केटप्लेस पर ऐप्लिकेशन बाइनरी को फिर से बनाने और सबमिट करने की ज़रूरत नहीं होगी.

यह आपके ऐप्लिकेशन में कॉन्फ़िगरेशन की किसी भी वैल्यू या फ़्लैग को मैनेज करने के लिए फ़ायदेमंद है. आपको आने वाले समय में इनमें बदलाव करने की ज़रूरत पड़ सकती है. जैसे:

  • यूज़र इंटरफ़ेस (यूआई) की अलग-अलग सेटिंग और डिसप्ले स्ट्रिंग
  • आपके ऐप्लिकेशन में दिखाए गए विज्ञापनों के साइज़, जगह या टाइप
  • गेम की सेटिंग

नियमों का इस्तेमाल करके, रनटाइम में कॉन्फ़िगरेशन वैल्यू का आकलन भी किया जा सकता है. इससे डाइनैमिक कॉन्फ़िगरेशन चालू किए जा सकते हैं. जैसे:

  • विज्ञापन बैनर का साइज़ तय करने के लिए स्क्रीन साइज़ का इस्तेमाल करना
  • यूज़र इंटरफ़ेस (यूआई) एलिमेंट को कॉन्फ़िगर करने के लिए, भाषा और जगह की जानकारी का इस्तेमाल करना

Google Tag Manager, ऐप्लिकेशन में ट्रैकिंग टैग और पिक्सल को डाइनैमिक तरीके से लागू करने की सुविधा भी देता है. डेवलपर, अहम इवेंट को डेटा लेयर में पुश कर सकते हैं. साथ ही, बाद में यह तय कर सकते हैं कि किन ट्रैकिंग टैग या पिक्सल को फ़ायर किया जाना चाहिए. TagManager में इन टैग का इस्तेमाल किया जा सकता है:

  • Google Mobile App Analytics
  • कस्टम फ़ंक्शन कॉल टैग

आरंभ करने से पहले

इस गाइड का इस्तेमाल करने से पहले, आपके पास ये चीज़ें होनी चाहिए:

अगर आपको Google Tag Manager का इस्तेमाल करते हुए ज़्यादा समय नहीं हुआ है, तो हमारा सुझाव है कि इस गाइड को पढ़ने से पहले, कंटेनर, मैक्रो, और नियमों के बारे में ज़्यादा जानें (सहायता केंद्र).

शुरू करें

इस सेक्शन में, डेवलपर को Tag Manager के सामान्य वर्कफ़्लो के बारे में बताया जाएगा:

  1. अपने प्रोजेक्ट में Google Tag Manager SDK जोड़ना
  2. कंटेनर की डिफ़ॉल्ट वैल्यू सेट करें
  3. कंटेनर खोलें
  4. कंटेनर से कॉन्फ़िगरेशन वैल्यू पाना
  5. DataLayer में इवेंट पुश करना
  6. कंटेनर की झलक देखना और उसे पब्लिश करना

1. अपने प्रोजेक्ट में Google Tag Manager SDK जोड़ना

Google Tag Manager SDK का इस्तेमाल करने से पहले, आपको अपने प्रोजेक्ट में SDK पैकेज की Library डायरेक्ट्री से libGoogleAnalyticsServices.a और Google Tag Manager (GTM) हेडर फ़ाइलें जोड़नी होंगी.

इसके बाद, अपने ऐप्लिकेशन टारगेट की लिंक की गई लाइब्रेरी में ये लाइब्रेरी जोड़ें. ऐसा तब करें, जब ये लाइब्रेरी पहले से मौजूद न हों:

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

अगर आपको Google Tag Manager SDK मैक्रो के ज़रिए, अपने ऐप्लिकेशन को विज्ञापन देने वाले लोगों या कंपनियों के लिए उपलब्ध आइडेंटिफ़ायर (आईडीएफ़ए) और उस फ़्रेमवर्क से मिले ट्रैकिंग फ़्लैग को ऐक्सेस करने की अनुमति देनी है, तो आपको इन अतिरिक्त लाइब्रेरी को भी लिंक करना होगा:

  • libAdIdAccess.a
  • AdSupport.framework

2. अपने प्रोजेक्ट में डिफ़ॉल्ट कंटेनर फ़ाइल जोड़ना

Google Tag Manager, आपके ऐप्लिकेशन के पहली बार चलने पर डिफ़ॉल्ट कंटेनर का इस्तेमाल करता है. जब तक ऐप्लिकेशन नेटवर्क पर नया कंटेनर नहीं पा लेता, तब तक डिफ़ॉल्ट कंटेनर का इस्तेमाल किया जाएगा.

अपने ऐप्लिकेशन में डिफ़ॉल्ट कंटेनर बाइनरी डाउनलोड करने और जोड़ने के लिए, यह तरीका अपनाएं:

  1. Google Tag Manager के वेब इंटरफ़ेस में साइन इन करें.
  2. कंटेनर का वह वर्शन चुनें जिसे आपको डाउनलोड करना है.
  3. कंटेनर बाइनरी को वापस पाने के लिए, डाउनलोड करें बटन पर क्लिक करें.
  4. बाइनरी फ़ाइल को अपने प्रोजेक्ट की रूट डायरेक्ट्री में जोड़ें. साथ ही, इसे अपने प्रोजेक्ट के "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 के वेब इंटरफ़ेस में टैग सेट अप किए जा सकते हैं. इससे, उन स्क्रीन व्यू के जवाब में कन्वर्ज़न पिक्सल और ट्रैकिंग कॉल ट्रिगर किए जा सकते हैं. इसके लिए, आपको उन्हें अपने ऐप्लिकेशन में हार्ड कोड करने की ज़रूरत नहीं होती.

push: का इस्तेमाल करके, इवेंट को DataLayer में पुश किया जाता है

//
//  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. कंटेनर की झलक देखना और उसे पब्लिश करना

मैक्रो वैल्यू हमेशा पब्लिश किए गए मौजूदा वर्शन से मेल खाएंगी. कंटेनर के नए वर्शन को पब्लिश करने से पहले, अपने ड्राफ़्ट कंटेनर की झलक देखी जा सकती है.

किसी कंटेनर की झलक देखने के लिए, Google Tag Manager के वेब इंटरफ़ेस में झलक देखने वाला यूआरएल जनरेट करें. इसके लिए, कंटेनर का वह वर्शन चुनें जिसकी झलक देखनी है. इसके बाद, Preview को चुनें. इस झलक वाले यूआरएल को सेव करें, क्योंकि आपको इसकी ज़रूरत बाद के चरणों में पड़ेगी.

झलक दिखाने वाले यूआरएल, Tag Manager के वेब इंटरफ़ेस की झलक दिखाने वाली विंडो में उपलब्ध होते हैं
पहली इमेज: Tag Manager के वेब इंटरफ़ेस से झलक देखने वाला यूआरएल पाना.

कंटेनर की झलक देखने की सुविधा चालू करने के लिए, आपको अपने ऐप्लिकेशन की डेलिगेट लागू करने वाली फ़ाइल में कोड जोड़ना होगा. साथ ही, अपने प्रोजेक्ट की प्रॉपर्टी लिस्ट में 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
अपने ऐप्लिकेशन की प्रॉपर्टी लिस्ट फ़ाइल में, Tag Manager की झलक देखने वाले यूआरएल स्कीम को रजिस्टर करें.
तीसरी इमेज: अपने ऐप्लिकेशन की प्रॉपर्टी लिस्ट फ़ाइल में, Tag Manager की झलक देखने वाले यूआरएल का स्कीम जोड़ना.

अपने ऐप्लिकेशन में ड्राफ़्ट कंटेनर की झलक देखने के लिए, एम्युलेटर या फ़िज़िकल डिवाइस पर लिंक खोलें.

जब आपको अपने ड्राफ़्ट कॉन्फ़िगरेशन की वैल्यू को अपने ऐप्लिकेशन के लिए उपलब्ध कराना हो, तब कंटेनर पब्लिश करें.

ऐडवांस कॉन्फ़िगरेशन

मोबाइल के लिए Google Tag Manager में कॉन्फ़िगरेशन के कई बेहतर विकल्प होते हैं. इनकी मदद से, नियमों का इस्तेमाल करके रनटाइम की स्थितियों के आधार पर वैल्यू चुनी जा सकती हैं. साथ ही, कंटेनर को मैन्युअल तरीके से रीफ़्रेश किया जा सकता है और कंटेनर खोलने के लिए अतिरिक्त विकल्प पाए जा सकते हैं. यहां दिए गए सेक्शन में, कुछ सबसे सामान्य ऐडवांस कॉन्फ़िगरेशन के बारे में बताया गया है.

कंटेनर खोलने के बेहतर विकल्प

Google Tag Manager SDK, कंटेनर खोलने के कई तरीके उपलब्ध कराता है. इससे आपको लोडिंग प्रोसेस पर ज़्यादा कंट्रोल मिलता है:

openContainerById:callback:

openContainerById:callback: सबसे कम लेवल और कंटेनर खोलने के लिए सबसे ज़्यादा फ़्लेक्सिबल एपीआई है. यह डिफ़ॉल्ट कंटेनर के साथ तुरंत जवाब देता है. साथ ही, अगर कोई सेव किया गया कंटेनर मौजूद नहीं है या सेव किया गया कंटेनर नया नहीं है (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: कई लाइफ़साइकल कॉलबैक देता है, ताकि आपका कोड यह पता लगा सके कि लोडिंग का अनुरोध कब शुरू होता है, यह अनुरोध पूरा हुआ या नहीं, और अगर नहीं हुआ, तो क्यों नहीं हुआ. साथ ही, यह भी पता लगा सके कि कंटेनर को आखिर में डिस्क या नेटवर्क से लोड किया गया था या नहीं.

अगर आपके ऐप्लिकेशन के लिए डिफ़ॉल्ट वैल्यू का इस्तेमाल करना ठीक नहीं है, तो आपको इन कॉलबैक का इस्तेमाल करना होगा. इससे आपको यह पता चलेगा कि सेव किया गया या नेटवर्क कंटेनर कब लोड हुआ है. ध्यान दें कि अगर ऐप्लिकेशन को पहली बार चलाया जा रहा है और कोई नेटवर्क कनेक्शन नहीं है, तो सेव किए गए या नेटवर्क कंटेनर को लोड नहीं किया जा सकेगा.

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 ऑब्जेक्ट दिखाता है. इसका get तरीका, लोड होने के तुरंत बाद TAGContainer दिखाता है. हालांकि, ऐसा होने तक यह ब्लॉक रहेगा. openContainerWithId:tagManager:openType:timeout:notifier: तरीके में एक कॉलबैक होता है. इसे तब कॉल किया जाता है, जब कंटेनर उपलब्ध होता है. दोनों तरीकों के लिए, डिफ़ॉल्ट टाइम आउट की अवधि 2.0 सेकंड होती है.

नियमों का इस्तेमाल करके, रनटाइम पर मैक्रो का आकलन करना

कंटेनर, नियमों का इस्तेमाल करके रनटाइम में वैल्यू का आकलन कर सकते हैं. नियम, डिवाइस की भाषा, प्लैटफ़ॉर्म या किसी अन्य मैक्रो वैल्यू जैसी शर्तों पर आधारित हो सकते हैं. उदाहरण के लिए, नियमों का इस्तेमाल करके, रनटाइम के दौरान डिवाइस की भाषा के आधार पर, स्थानीय भाषा में डिसप्ले स्ट्रिंग को चुना जा सकता है. इसे इस नियम का इस्तेमाल करके कॉन्फ़िगर किया जा सकता है:

इस नियम का इस्तेमाल, डिवाइस की भाषा के आधार पर डिसप्ले स्ट्रिंग चुनने के लिए किया जाता है. यह नियम रनटाइम पर लागू होता है: भाषा es के बराबर है. इस नियम में, पहले से तय किया गया भाषा मैक्रो और दो वर्णों वाला ISO 639-1 भाषा कोड इस्तेमाल किया जाता है.
पहली इमेज:स्पैनिश भाषा का इस्तेमाल करने के लिए कॉन्फ़िगर किए गए डिवाइसों के लिए, वैल्यू कलेक्शन मैक्रो को चालू करने का नियम जोड़ा जा रहा है.

इसके बाद, हर भाषा के लिए वैल्यू कलेक्शन मैक्रो बनाए जा सकते हैं. साथ ही, हर मैक्रो में यह नियम जोड़ा जा सकता है. इसके लिए, सही भाषा कोड डालें. इस कंटेनर को पब्लिश करने पर, आपका ऐप्लिकेशन रनटाइम में उपयोगकर्ता के डिवाइस की भाषा के हिसाब से, स्थानीय भाषा में डिसप्ले स्ट्रिंग दिखा पाएगा.

ध्यान दें कि अगर आपके डिफ़ॉल्ट कंटेनर के लिए नियमों की ज़रूरत है, तो आपको अपने डिफ़ॉल्ट कंटेनर के तौर पर बाइनरी कंटेनर फ़ाइल का इस्तेमाल करना होगा.

नियमों को कॉन्फ़िगर करने के बारे में ज़्यादा जानें (सहायता केंद्र).

बाइनरी डिफ़ॉल्ट कंटेनर फ़ाइलें

जिन डिफ़ॉल्ट कंटेनर के लिए नियमों की ज़रूरत होती है उन्हें डिफ़ॉल्ट कंटेनर के तौर पर, प्रॉपर्टी की सूची वाली फ़ाइल या JSON फ़ाइल के बजाय बाइनरी कंटेनर फ़ाइल का इस्तेमाल करना चाहिए. बाइनरी कंटेनर, Google Tag Manager के नियमों के साथ रनटाइम पर मैक्रो वैल्यू तय करने की सुविधा देते हैं. हालांकि, प्रॉपर्टी लिस्ट या JSON फ़ाइलें यह सुविधा नहीं देती हैं.

बाइनरी कंटेनर फ़ाइलों को Google Tag Manager के वेब इंटरफ़ेस से डाउनलोड किया जा सकता है. इन्हें इस नामकरण के तरीके के मुताबिक, अपने मुख्य ऐप्लिकेशन बंडल में जोड़ा जाना चाहिए: GTM-XXXX. यहां फ़ाइल का नाम, आपके कंटेनर आईडी को दिखाता है.

अगर प्रॉपर्टी लिस्ट फ़ाइल और/या JSON फ़ाइल के साथ-साथ बाइनरी कंटेनर फ़ाइल भी मौजूद है, तो SDK टूल, बाइनरी कंटेनर फ़ाइल को डिफ़ॉल्ट कंटेनर के तौर पर इस्तेमाल करेगा.

फ़ंक्शन कॉल मैक्रो का इस्तेमाल करना

फ़ंक्शन कॉल मैक्रो ऐसे मैक्रो होते हैं जिन्हें आपके ऐप्लिकेशन में किसी फ़ंक्शन की रिटर्न वैल्यू पर सेट किया जाता है. फ़ंक्शन कॉल मैक्रो का इस्तेमाल इन कामों के लिए किया जा सकता है: Google Tag Manager के नियमों में रनटाइम वैल्यू शामिल करने के लिए. जैसे, यह तय करने के लिए कि रनटाइम में, किसी उपयोगकर्ता को डिवाइस की कॉन्फ़िगर की गई भाषा और मुद्रा के आधार पर कौनसी कीमत दिखाई जाए.

फ़ंक्शन कॉल मैक्रो को कॉन्फ़िगर करने के लिए:

  1. Google Tag Manager के वेब इंटरफ़ेस में, फ़ंक्शन कॉल मैक्रो तय करें. आर्गुमेंट को की-वैल्यू पेयर के तौर पर कॉन्फ़िगर किया जा सकता है.
  2. ऐसा हैंडलर तय करें जो 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. 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 के तौर पर तय होते हैं.

फ़ंक्शन कॉल टैग को कॉन्फ़िगर करने के लिए:

  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 घंटे से ज़्यादा पुराना है, तो Google Tag Manager SDK एक नया कंटेनर पाने की कोशिश करेगा. कंटेनर रीफ़्रेश करने की अवधि को अपनी पसंद के मुताबिक सेट करने के लिए, NSTimer का इस्तेमाल करें. उदाहरण के लिए:

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

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

लॉगर की मदद से डीबग करना

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 सेट करने के लिए, 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];