Android v3 (लेगसी) - खास जानकारी

इस डेवलपर गाइड में, मोबाइल ऐप्लिकेशन में 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 पैकेज को एक्सट्रैक्ट करना होगा. साथ ही, लाइब्रेरी को अपने प्रोजेक्ट के बिल्ड पाथ में जोड़ना होगा और अपनी AndroidManifest.xml फ़ाइल में अनुमतियां जोड़नी होंगी.

सबसे पहले, Google Tag Manager लाइब्रेरी को अपने प्रोजेक्ट के /libs फ़ोल्डर में जोड़ें.

इसके बाद, AndroidManifest.xml फ़ाइल को अपडेट करें, ताकि ये अनुमतियां इस्तेमाल की जा सकें:

<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
<uses-permission android:name="android.permission.INTERNET" />

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

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

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

  1. Google Tag Manager के वेब इंटरफ़ेस में साइन इन करें.
  2. कंटेनर का वह वर्शन चुनें जिसे आपको डाउनलोड करना है.
  3. कंटेनर बाइनरी को वापस पाने के लिए, डाउनलोड करें बटन पर क्लिक करें.
  4. बाइनरी फ़ाइल को इस पाथ पर जोड़ें: <project-root>/assets/tagmanager/

डिफ़ॉल्ट फ़ाइल का नाम, कंटेनर आईडी होना चाहिए. उदाहरण के लिए, GTM-1234. बाइनरी फ़ाइल डाउनलोड करने के बाद, फ़ाइल के नाम से वर्शन सफ़िक्स हटाना न भूलें. इससे यह पक्का किया जा सकेगा कि आपने नाम रखने के सही तरीके का पालन किया है.

हालांकि, बाइनरी फ़ाइल का इस्तेमाल करने का सुझाव दिया जाता है. अगर आपके कंटेनर में नियम या टैग नहीं हैं, तो इसके बजाय JSON फ़ाइल का इस्तेमाल किया जा सकता है. फ़ाइल को आपके Android प्रोजेक्ट के नए /assets/tagmanager फ़ोल्डर में होना चाहिए. साथ ही, फ़ाइल का नाम इस फ़ॉर्मैट में होना चाहिए: <Container_ID>.json. उदाहरण के लिए, अगर आपका कंटेनर आईडी GTM-1234 है, तो आपको अपने डिफ़ॉल्ट कंटेनर की वैल्यू को /assets/tagmanager/GTM-1234.json में जोड़ना चाहिए.

3. कंटेनर खोलना

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

Android पर किसी कंटेनर को खोलने का सबसे आसान तरीका, ContainerOpener.openContainer(..., Notifier notifier) का इस्तेमाल करना है. उदाहरण के लिए:

import com.google.tagmanager.Container;
import com.google.tagmanager.ContainerOpener;
import com.google.tagmanager.ContainerOpener.OpenType;
import com.google.tagmanager.TagManager;

import android.app.Activity;
import android.os.Bundle;

public class RacingGame {

  // Add your public container ID.
  private static final String CONTAINER_ID = "GTM-YYYY";

  volatile private Container mContainer;

  @Override
  public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    TagManager mTagManager = TagManager.getInstance(this);

    // The container is returned to containerFuture when available.
    ContainerOpener.openContainer(
        mTagManager,                            // TagManager instance.
        CONTAINER_ID,                           // Tag Manager Container ID.
        OpenType.PREFER_NON_DEFAULT,            // Prefer not to get the default container, but stale is OK.
        null,                                   // Time to wait for saved container to load (ms). Default is 2000ms.
        new ContainerOpener.Notifier() {        // Called when container loads.
          @Override
          public void containerAvailable(Container container) {
            // Handle assignment in callback to avoid blocking main thread.
            mContainer = container;
          }
        }
    );
    // Rest of your onCreate code.
  }
}

इस उदाहरण में, ContainerOpener.openContainer(..., Notifier notifier) का इस्तेमाल, लोकल स्टोरेज से सेव किए गए कंटेनर का अनुरोध करने के लिए किया जाता है. containerAvailable कॉलबैक में mContainer असाइनमेंट को मैनेज करके, हम यह पक्का करते हैं कि मुख्य थ्रेड ब्लॉक न हो. अगर सेव किया गया कंटेनर 12 घंटे से ज़्यादा पुराना है, तो कॉल, नेटवर्क पर एसिंक्रोनस तरीके से नया कंटेनर पाने के लिए भी अनुरोध शेड्यूल करेगा.

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

4. कंटेनर से कॉन्फ़िगरेशन वैल्यू पाना

कंटेनर खुलने के बाद, get<type>Value() तरीकों का इस्तेमाल करके कॉन्फ़िगरेशन वैल्यू वापस पाई जा सकती हैं:

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

// Get the configuration value by key.
String title = mContainer.getStringValue("title_string");

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

// Empty keys will return a default value depending on the type requested.

// Key does not exist. An empty string is returned.
string subtitle = container.getStringValue("Non-existent-key");
subtitle.equals(""); // Evaluates to true.

5. DataLayer में वैल्यू पुश करना

DataLayer एक मैप होता है. यह आपके ऐप्लिकेशन के बारे में रनटाइम की जानकारी उपलब्ध कराता है. जैसे, टच इवेंट या स्क्रीन व्यू. यह जानकारी, कंटेनर में मौजूद Tag Manager मैक्रो और टैग के लिए उपलब्ध होती है.

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

इवेंट को DataLayer में पुश करने के लिए, push() और DataLayer.mapOf() हेल्पर तरीके का इस्तेमाल किया जाता है:

//
// MainActivity.java
// Pushing an openScreen event with a screen name into the data layer.
//

import com.google.tagmanager.TagManager;
import com.google.tagmanager.DataLayer;

import android.app.Activity;
import android.os.Bundle;

public MainActivity extends Activity {

  public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);

  }

  // This screen becomes visible when Activity.onStart() is called.
  public void onStart() {
    super.onStart();

    // The container should have already been opened, otherwise events pushed to
    // the DataLayer will not fire tags in that container.
    DataLayer dataLayer = TagManager.getInstance(this).getDataLayer();
    dataLayer.push(DataLayer.mapOf("event",
                                   "openScreen",      // The event type. This value should be used consistently for similar event types.
                                   "screenName",      // Writes a key "screenName" to the dataLayer map.
                                   "Home Screen")     // Writes a value "Home Screen" for the "screenName" key.
    );
  }
  // Rest of the Activity implementation
}

वेब इंटरफ़ेस में, अब टैग (जैसे कि Google Analytics टैग) बनाए जा सकते हैं. ये टैग, हर स्क्रीन व्यू के लिए ट्रिगर होंगे. इसके लिए, यह नियम बनाएं: equals "openScreen". स्क्रीन का नाम इनमें से किसी एक टैग को पास करने के लिए, एक डेटा लेयर मैक्रो बनाएं. यह मैक्रो, डेटा लेयर में "screenName" कुंजी को रेफ़रंस करता है. किसी टैग (जैसे कि Google Ads कन्वर्ज़न पिक्सल) को सिर्फ़ खास स्क्रीन व्यू के लिए भी ट्रिगर किया जा सकता है. इसके लिए, ऐसा नियम बनाएं जहां "openScreen" && "ConfirmationScreen" के बराबर हो.

6. कंटेनर की झलक देखना और उसे पब्लिश करना

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

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

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

इसके बाद, अपने ऐप्लिकेशन की AndroidManifest.xml फ़ाइल में यह ऐक्टिविटी जोड़ें:

<!-- Google Tag Manager Preview Activity -->
<activity
  android:name="com.google.tagmanager.PreviewActivity"
  android:label="@string/app_name"
  android:noHistory="true" >  <!-- Optional, removes the PreviewActivity from activity stack. -->
  <intent-filter>
    <data android:scheme="tagmanager.c.application_package_name" />
    <action android:name="android.intent.action.VIEW" />
    <category android:name="android.intent.category.DEFAULT" />
    <category android:name="android.intent.category.BROWSABLE"/>
  </intent-filter>
</activity>

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

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

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

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

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

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

TagManager.openContainer()

TagManager.openContainer() सबसे कम लेवल और कंटेनर खोलने के लिए सबसे ज़्यादा फ़्लेक्सिबल एपीआई है. यह डिफ़ॉल्ट कंटेनर के साथ तुरंत जवाब देता है. साथ ही, अगर कोई सेव किया गया कंटेनर मौजूद नहीं है या सेव किया गया कंटेनर नया नहीं है (12 घंटे से ज़्यादा पुराना है), तो यह डिस्क या नेटवर्क से कंटेनर को एसिंक्रोनस तरीके से लोड करता है.

mContainer = tagManager.openContainer(CONTAINER_ID, new Container.Callback() {

  // Called when a refresh is about to begin for the given refresh type.
  @Override
  public void containerRefreshBegin(Container container, RefreshType refreshType) {
    // Notify UI that the Container refresh is beginning.
   }

  // Called when a successful refresh occurred for the given refresh type.
  @Override
  public void containerRefreshSuccess(Container container, RefreshType refreshType]) {
    // Notify UI that Container is ready.
  }

  // Called when a refresh failed for the given refresh type.
  @Override
  public void containerRefreshFailure(Container container,
                                      RefreshType refreshType,
                                      RefreshFailure refreshFailure) {
    // Notify UI that the Container refresh has failed.
  }

लोडिंग की पूरी प्रोसेस के दौरान, TagManager.openContainer() कई लाइफ़साइकल कॉलबैक देता है, ताकि आपका कोड यह पता लगा सके कि लोडिंग का अनुरोध कब शुरू होता है, यह अनुरोध पूरा हुआ या नहीं, और अगर नहीं हुआ, तो क्यों नहीं हुआ. साथ ही, यह भी पता लगा सके कि कंटेनर को आखिर में डिस्क या नेटवर्क से लोड किया गया था या नहीं.

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

TagManager.openContainer() इन कॉलबैक में, enum इन वैल्यू को आर्ग्युमेंट के तौर पर पास करता है:

RefreshType

मानब्यौरा
Container.Callback.SAVED रीफ़्रेश करने का अनुरोध, डिवाइस में सेव किए गए कंटेनर को लोड कर रहा है.
Container.Callback.NETWORK रीफ़्रेश करने का अनुरोध, नेटवर्क पर कंटेनर लोड कर रहा है.

RefreshFailure

मानब्यौरा
Container.Callback.NO_SAVED_CONTAINER सेव किया गया कोई कंटेनर उपलब्ध नहीं है.
Container.Callback.IO_ERROR I/O गड़बड़ी की वजह से, कंटेनर को रीफ़्रेश नहीं किया जा सका.
Container.Callback.NO_NETWORK कोई नेटवर्क कनेक्शन उपलब्ध नहीं है.
Container.Callback.NETWORK_ERROR नेटवर्क में कोई गड़बड़ी हुई है.
Container.Callback.SERVER_ERROR सर्वर में कोई गड़बड़ी हुई है.
Container.Callback.UNKNOWN_ERROR ऐसी गड़बड़ी हुई है जिसे किसी कैटगरी में नहीं रखा जा सकता.

नॉन-डिफ़ॉल्ट और नए कंटेनर खोलने के तरीके

ContainerOpener, TagManager.openContainer() को रैप करता है. साथ ही, कंटेनर खोलने के दो आसान तरीके उपलब्ध कराता है: ContainerOpener.openContainer(..., Notifier notifier) और ContainerOpener.openContainer(..., Long timeoutInMillis).

इनमें से हर तरीके में, एक ऐसा एन्यूमरेशन होता है जो गैर-डिफ़ॉल्ट या नया कंटेनर का अनुरोध करता है.

OpenType.PREFER_NON_DEFAULT का इस्तेमाल ज़्यादातर ऐप्लिकेशन के लिए किया जाता है. साथ ही, यह दिए गए टाइम आउट पीरियड में, डिस्क या नेटवर्क से उपलब्ध पहले नॉन-डिफ़ॉल्ट कंटेनर को वापस लाने की कोशिश करता है. भले ही, वह कंटेनर 12 घंटे से ज़्यादा पुराना हो. अगर यह सेव किए गए पुराने कंटेनर को दिखाता है, तो यह नए कंटेनर के लिए एसिंक्रोनस नेटवर्क अनुरोध भी करेगा. OpenType.PREFER_NON_DEFAULT का इस्तेमाल करते समय, अगर कोई दूसरा कंटेनर उपलब्ध नहीं है या टाइम आउट की अवधि खत्म हो गई है, तो डिफ़ॉल्ट कंटेनर वापस कर दिया जाएगा.

OpenType.PREFER_FRESH दिए गए टाइम आउट पीरियड में, डिस्क या नेटवर्क से नया कंटेनर वापस लाने की कोशिश करता है. अगर नेटवर्क कनेक्शन उपलब्ध नहीं है और/या टाइम आउट की अवधि खत्म हो गई है, तो यह सेव किया गया कंटेनर दिखाता है.

हमारा सुझाव है कि OpenType.PREFER_FRESH का इस्तेमाल उन जगहों पर न करें जहां अनुरोध पूरा होने में ज़्यादा समय लगने से, उपयोगकर्ता अनुभव पर असर पड़ सकता है. जैसे, यूज़र इंटरफ़ेस (यूआई) फ़्लैग या डिसप्ले स्ट्रिंग के साथ. नेटवर्क कंटेनर के अनुरोध को फ़ोर्स करने के लिए, Container.refresh() का इस्तेमाल किसी भी समय किया जा सकता है.

ये दोनों तरीके, बिना किसी रुकावट के काम करते हैं. ContainerOpener.openContainer(..., Long timeoutInMillis), एक ContainerOpener.ContainerFuture ऑब्जेक्ट दिखाता है. इसका get तरीका, लोड होने के तुरंत बाद Container दिखाता है. हालांकि, ऐसा होने तक यह ब्लॉक रहेगा. ContainerOpener.openContainer(..., Notifier notifier) तरीके में एक कॉलबैक होता है. जब कंटेनर उपलब्ध होता है, तब इसे कॉल किया जाता है. इसका इस्तेमाल मुख्य थ्रेड को ब्लॉक होने से रोकने के लिए किया जा सकता है. दोनों तरीकों के लिए, समय खत्म होने की डिफ़ॉल्ट अवधि 2000 मिलीसेकंड होती है.

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

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

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

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

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

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

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

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

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

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

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

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

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

  1. Google Tag Manager के वेब इंटरफ़ेस में, फ़ंक्शन कॉल मैक्रो तय करें. आर्गुमेंट को की-वैल्यू पेयर के तौर पर कॉन्फ़िगर किया जा सकता है.
  2. अपने ऐप्लिकेशन में FunctionCallMacroHandler रजिस्टर करें. इसके लिए, Container.registerFunctionCallMacroHandler() और Google Tag Manager के वेब इंटरफ़ेस में कॉन्फ़िगर किया गया फ़ंक्शन का नाम इस्तेमाल करें. साथ ही, इसके getValue() तरीके को बदलें: 
    /**
 * Registers a function call macro handler.
 *
 * @param functionName The function name field, as defined in the Google Tag
 *     Manager web interface.
 */
mContainer.registerFunctionCallMacroHandler(functionName, new FunctionCallMacroHandler() {

  /**
   * This code will execute when any custom macro's rule(s) evaluate to true.
   * The code should check the functionName and process accordingly.
   *
   * @param functionName Corresponds to the function 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.
   */
  @Override
  public Object getValue(String functionName, Map<String, Object> parameters)) {

    if (functionName.equals("myConfiguredFunctionName")) {
      // Process and return the calculated value of this macro accordingly.
      return macro_value
    }
    return null;
  }
});

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

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

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

  1. Google Tag Manager के वेब इंटरफ़ेस में फ़ंक्शन कॉल टैग तय करें. आर्गुमेंट को की-वैल्यू पेयर के तौर पर कॉन्फ़िगर किया जा सकता है.
  2. Container.registerFunctionCallTagHandler() का इस्तेमाल करके, अपने ऐप्लिकेशन में फ़ंक्शन कॉल टैग हैंडलर रजिस्टर करें: 
    /**
 * Register a function call tag handler.
 *
 * @param functionName The function name, which corresponds to the function name field
 *     Google Tag Manager web interface.
 */
mContainer.registerFunctionCallTagHandler(functionName, new FunctionCallTagHandler() {

  /**
   * This method will be called when any custom tag's rule(s) evaluates to true.
   * The code should check the functionName and process accordingly.
   *
   * @param functionName The functionName passed to the functionCallTagHandler.
   * @param parameters An optional map of parameters as defined in the Google
   *     Tag Manager web interface.
   */
  @Override
  public void execute(String functionName, Map<String, Object> parameters) {
    if (functionName.equals("myConfiguredFunctionName")) {
      // Process accordingly.
    }
  }
});

रीफ़्रेश करने के लिए कस्टम पीरियड सेट करना

अगर मौजूदा कंटेनर 12 घंटे से ज़्यादा पुराना है, तो Google Tag Manager SDK एक नया कंटेनर पाने की कोशिश करेगा. कंटेनर रीफ़्रेश करने की अवधि को अपनी पसंद के मुताबिक सेट करने के लिए, Timer का इस्तेमाल करें. जैसे, इस उदाहरण में दिखाया गया है:

timer.scheduleTask(new TimerTask() {
  @Override
  public void run() {
    mContainer.refresh();
  }
}, delay, <new_period_in milliseconds>);

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

Google Tag Manager SDK, डिफ़ॉल्ट रूप से गड़बड़ियों और चेतावनियों को लॉग में प्रिंट करता है. ज़्यादा वर्बोस लॉगिंग चालू करने से डीबग करने में मदद मिल सकती है. इसके लिए, Logger के साथ TagManager.setLogger को लागू करें. उदाहरण के लिए:

TagManager tagManager = TagManager.getInstance(this);
tagManager.setLogger(new Logger() {

  final String TAG = "myGtmLogger";

  // Log output with verbosity level of DEBUG.
  @Override
  public void d(String arg0) {
    Log.d(TAG, arg0);
  }

  // Log exceptions when provided.
  @Override
  public void d(String arg0, Throwable arg1) {
    Log.d(TAG, arg0);
    arg1.printStackTrace();
  }

  // Rest of the unimplemented Logger methods.

});

इसके अलावा, मौजूदा लॉगर का LogLevel सेट करने के लिए, TagManager.getLogger().setLogLevel(LogLevel) का इस्तेमाल किया जा सकता है. जैसे, इस उदाहरण में दिखाया गया है:

// Change the LogLevel to INFO to enable logging at INFO and higher levels.
TagManager tagManager = TagManager.getInstance(this);
tagManager.getLogger().setLogLevel(LogLevel.INFO);