Android v3 (เดิม) - ภาพรวม

คู่มือนักพัฒนาซอฟต์แวร์นี้จะอธิบายวิธีติดตั้ง Google Tag Manager ในแอปพลิเคชันบนอุปกรณ์เคลื่อนที่

เกริ่นนำ

Google Tag Manager ช่วยให้นักพัฒนาซอฟต์แวร์เปลี่ยนการกำหนดค่าในแอปพลิเคชันบนอุปกรณ์เคลื่อนที่ของตนโดยใช้อินเทอร์เฟซ Google Tag Manager โดยไม่ต้องสร้างและส่งคำขอไบนารีแอปพลิเคชันไปยังตลาดกลางแอปอีกครั้ง

ซึ่งจะมีประโยชน์ในการจัดการค่าของการกำหนดค่าหรือแฟล็กในแอปพลิเคชันที่คุณอาจต้องเปลี่ยนแปลงในอนาคต เช่น

  • การตั้งค่า UI และสตริงการแสดงผลแบบต่างๆ
  • ขนาด สถานที่ตั้ง หรือประเภทของโฆษณาที่แสดงในแอปพลิเคชัน
  • การตั้งค่าเกม

ระบบอาจประเมินค่าของการกำหนดค่าขณะรันไทม์โดยใช้กฎต่างๆ ซึ่งจะเป็นการเปิดใช้การกำหนดค่าแบบไดนามิก เช่น

  • การใช้ขนาดหน้าจอเพื่อกำหนดขนาดโฆษณาแบนเนอร์
  • การใช้ภาษาและตำแหน่งเพื่อกำหนดค่าองค์ประกอบ UI

Google Tag Manager ยังเปิดใช้การติดตั้งใช้งานแท็กและพิกเซลติดตามในแอปพลิเคชันแบบไดนามิกได้ด้วย นักพัฒนาซอฟต์แวร์จะพุชเหตุการณ์สำคัญเข้าไปในชั้นข้อมูลและตัดสินใจในภายหลังได้ว่าควรให้แท็กหรือพิกเซลติดตามใดเริ่มทำงาน ปัจจุบัน Tag Manager รองรับแท็กต่อไปนี้

  • Analytics สำหรับ Google Mobile App
  • แท็กการเรียกใช้ฟังก์ชันที่กำหนดเอง

ก่อนที่คุณจะเริ่ม

ก่อนใช้คู่มือเริ่มต้นใช้งานนี้ คุณจะต้องมีสิ่งต่อไปนี้

หากคุณเพิ่งเริ่มใช้ 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 เครื่องจัดการแท็กใช้คอนเทนเนอร์เริ่มต้นเมื่อเรียกใช้แอปพลิเคชันครั้งแรก ระบบจะใช้คอนเทนเนอร์เริ่มต้นจนกว่าแอปจะสามารถดึงข้อมูลคอนเทนเนอร์ใหม่ผ่านเครือข่ายได้

หากต้องการดาวน์โหลดและเพิ่มไบนารีของคอนเทนเนอร์เริ่มต้นลงในแอปพลิเคชัน ให้ทำตามขั้นตอนต่อไปนี้

  1. ลงชื่อเข้าใช้เว็บอินเทอร์เฟซของ Google Tag Manager
  2. เลือกเวอร์ชันของคอนเทนเนอร์ที่ต้องการดาวน์โหลด
  3. คลิกปุ่มดาวน์โหลดเพื่อเรียกข้อมูลไบนารีคอนเทนเนอร์
  4. เพิ่มไฟล์ไบนารีไปยังเส้นทางต่อไปนี้ <project-root>/assets/tagmanager/

ชื่อไฟล์เริ่มต้นควรเป็นรหัสคอนเทนเนอร์ (เช่น GTM-1234) เมื่อดาวน์โหลดไฟล์ไบนารีแล้ว อย่าลืมนำคำต่อท้ายเวอร์ชันออกจากชื่อไฟล์เพื่อให้แน่ใจว่าคุณตั้งชื่อตามแบบแผนการตั้งชื่อที่ถูกต้อง

แม้ว่าระบบจะแนะนำให้ใช้ไฟล์ไบนารี แต่หากคอนเทนเนอร์ไม่มีกฎหรือแท็ก คุณอาจเลือกใช้ไฟล์ JSON แบบง่ายแทนก็ได้ ไฟล์ต้องอยู่ในโฟลเดอร์ /assets/tagmanager ใหม่สำหรับโปรเจ็กต์ Android ของคุณและควรเป็นไปตามรูปแบบการตั้งชื่อนี้ <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) เพื่อขอคอนเทนเนอร์ที่บันทึกไว้จากพื้นที่เก็บข้อมูลในเครื่อง การจัดการการมอบหมาย mContainer ในโค้ดเรียกกลับของ containerAvailable จะทำให้เทรดหลักไม่ถูกบล็อก หากคอนเทนเนอร์ที่บันทึกไว้เก่ากว่า 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 เพื่อเริ่มการทำงานของพิกเซล Conversion และติดตามการโทรเพื่อตอบสนองต่อการดูหน้าจอเหล่านั้นได้โดยไม่ต้องฮาร์ดโค้ดลงในแอป

ระบบจะพุชเหตุการณ์ไปยัง 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) เพื่อเริ่มการทำงานของการดูหน้าจอแต่ละครั้งได้แล้วด้วยการสร้างกฎต่อไปนี้ เท่ากับ "openScreen" หากต้องการส่งชื่อหน้าจอไปยังแท็กใดแท็กหนึ่งเหล่านี้ ให้สร้างมาโครชั้นข้อมูลที่อ้างอิงคีย์ "screenName" ในชั้นข้อมูล นอกจากนี้ คุณยังสร้างแท็ก (เช่น พิกเซล Conversion ของ Google Ads) เพื่อให้เริ่มทํางานสําหรับการดูหน้าจอที่เจาะจงเท่านั้นได้ด้วย โดยสร้างกฎที่ เท่ากับ "openScreen" && เท่ากับ "ConfirmationScreen"

6. การดูตัวอย่างและการเผยแพร่คอนเทนเนอร์

ค่ามาโครจะสอดคล้องกับเวอร์ชันที่เผยแพร่ปัจจุบันเสมอ ก่อนที่จะเผยแพร่คอนเทนเนอร์เวอร์ชันล่าสุด คุณสามารถดูตัวอย่างคอนเทนเนอร์แบบร่างได้

หากต้องการดูตัวอย่างคอนเทนเนอร์ ให้สร้าง URL ตัวอย่างในอินเทอร์เฟซเว็บของ Google Tag Manager โดยเลือกเวอร์ชันของคอนเทนเนอร์ที่ต้องการดูตัวอย่าง แล้วเลือก Preview โปรดใช้ URL หน้าตัวอย่างนี้เพราะคุณจะต้องใช้ในขั้นตอนถัดไป

URL ตัวอย่างจะแสดงในหน้าต่างแสดงตัวอย่างของอินเทอร์เฟซเว็บของ Tag Manager
ภาพที่ 1: การรับ URL ตัวอย่างจากอินเทอร์เฟซเว็บของ 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() เป็น API ระดับต่ำสุดและยืดหยุ่นที่สุดสำหรับการเปิดคอนเทนเนอร์ โดยระบบจะส่งคืนคอนเทนเนอร์เริ่มต้นทันทีและโหลดคอนเทนเนอร์จากดิสก์หรือเครือข่ายแบบไม่พร้อมกัน ถ้าไม่มีคอนเทนเนอร์ที่บันทึกไว้อยู่หรือหากคอนเทนเนอร์ที่บันทึกไว้ไม่เป็นปัจจุบัน (เก่ากว่า 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() และมีวิธีอำนวยความสะดวก 2 วิธีในการเปิดคอนเทนเนอร์ ได้แก่ ContainerOpener.openContainer(..., Notifier notifier) และ ContainerOpener.openContainer(..., Long timeoutInMillis)

แต่ละเมธอดจะใช้การแจกแจงที่ขอคอนเทนเนอร์ที่ไม่ใช่ค่าเริ่มต้นหรือคอนเทนเนอร์ใหม่

ขอแนะนำให้ใช้ OpenType.PREFER_NON_DEFAULT กับแอปพลิเคชันส่วนใหญ่และพยายามแสดงผลคอนเทนเนอร์แรกที่ไม่ใช่ค่าเริ่มต้นที่ใช้งานได้ภายในระยะเวลาที่กำหนด ไม่ว่าจะจากดิสก์หรือเครือข่ายแม้ว่าคอนเทนเนอร์นั้นจะมีอายุเกิน 12 ชั่วโมงก็ตาม หากแสดงผลคอนเทนเนอร์ที่บันทึกไว้ที่ไม่มีอัปเดต ระบบจะส่งคำขอเครือข่ายแบบไม่พร้อมกันสำหรับคอนเทนเนอร์ใหม่ เมื่อใช้ OpenType.PREFER_NON_DEFAULT ระบบจะแสดงผลคอนเทนเนอร์เริ่มต้นหากไม่มีคอนเทนเนอร์อื่นที่พร้อมใช้งาน หรือหากเกินระยะหมดเวลา

OpenType.PREFER_FRESH จะพยายามส่งคืนคอนเทนเนอร์ใหม่จากดิสก์หรือเครือข่ายภายในระยะหมดเวลาที่ระบุ โดยจะแสดงคอนเทนเนอร์ที่บันทึกไว้หากไม่มีการเชื่อมต่อเครือข่ายและ/หรือเกินระยะหมดเวลา

ไม่แนะนำให้ใช้ OpenType.PREFER_FRESH ในตำแหน่งที่ใช้เวลานานในการส่งคำขอ ซึ่งอาจส่งผลต่อประสบการณ์ของผู้ใช้อย่างเห็นได้ชัด เช่น เมื่อมีแฟล็ก UI หรือสตริงการแสดงผล นอกจากนี้ คุณยังอาจใช้ Container.refresh() เพื่อบังคับคำขอคอนเทนเนอร์เครือข่ายได้ทุกเมื่อ

ความสะดวกทั้งสองนี้แบบไม่บล็อกการทำงาน ContainerOpener.openContainer(..., Long timeoutInMillis) แสดงผลออบเจ็กต์ ContainerOpener.ContainerFuture ซึ่งเมธอด get แสดงผล Container ทันทีที่โหลด (แต่จะบล็อกจนกว่าจะถึงเวลาดังกล่าว) เมธอด ContainerOpener.openContainer(..., Notifier notifier) จะใช้โค้ดเรียกกลับครั้งเดียวสำหรับเรียกใช้เมื่อคอนเทนเนอร์พร้อมใช้งาน ซึ่งสามารถใช้เพื่อป้องกันการบล็อกเทรดหลัก ทั้ง 2 วิธีมีระยะหมดเวลาเริ่มต้นอยู่ที่ 2000 มิลลิวินาที

การประเมินมาโครขณะรันไทม์โดยใช้กฎ

คอนเทนเนอร์จะประเมินค่าขณะรันไทม์โดยใช้กฎได้ กฎอาจอิงตามเกณฑ์ต่างๆ เช่น ภาษาของอุปกรณ์ แพลตฟอร์ม หรือค่ามาโครอื่นๆ ตัวอย่างเช่น กฎอาจใช้เพื่อเลือกสตริงที่แสดงที่แปลแล้วโดยอิงตามภาษาของอุปกรณ์ขณะรันไทม์ได้ ซึ่งคุณจะกำหนดค่าได้โดยใช้กฎต่อไปนี้

กฎใช้เพื่อเลือกสตริงที่แสดงตามภาษาของอุปกรณ์ขณะรันไทม์: ภาษาเท่ากับ es กฎนี้ใช้มาโครภาษาที่กำหนดไว้ล่วงหน้าและรหัสภาษา ISO 639-1 แบบ 2 อักขระ
ภาพที่ 1: การเพิ่มกฎเพื่อเปิดใช้มาโครคอลเล็กชันค่าสำหรับอุปกรณ์ที่กำหนดค่าให้ใช้ภาษาสเปนเท่านั้น

จากนั้นคุณสามารถสร้างมาโครคอลเล็กชันค่าสำหรับแต่ละภาษา และเพิ่มกฎนี้ลงในมาโครแต่ละรายการโดยใส่รหัสภาษาที่เหมาะสม เมื่อนำคอนเทนเนอร์นี้ไปใช้จริง แอปพลิเคชันจะแสดงสตริงการแสดงผลที่แปลแล้ว โดยขึ้นอยู่กับภาษาของอุปกรณ์ของผู้ใช้ในขณะรันไทม์

โปรดทราบว่าหากคอนเทนเนอร์เริ่มต้นจำเป็นต้องใช้กฎ คุณต้องใช้ไฟล์คอนเทนเนอร์ไบนารีเป็นคอนเทนเนอร์เริ่มต้น

ดูข้อมูลเพิ่มเติมเกี่ยวกับการกำหนดค่ากฎ (ศูนย์ช่วยเหลือ)

ไฟล์คอนเทนเนอร์เริ่มต้นแบบไบนารี

คอนเทนเนอร์เริ่มต้นที่ต้องใช้กฎควรใช้ไฟล์คอนเทนเนอร์ไบนารีแทนไฟล์ JSON เป็นคอนเทนเนอร์เริ่มต้น คอนเทนเนอร์ไบนารีรองรับการกำหนดค่ามาโครขณะรันไทม์ด้วยกฎของ Google Tag Manager ในขณะที่ไฟล์ JSON ไม่รองรับ

คุณสามารถดาวน์โหลดไฟล์คอนเทนเนอร์ไบนารีจากอินเทอร์เฟซเว็บของ Google Tag Manager และควรเพิ่มลงในโฟลเดอร์ /assets/tagmanager/ ของโปรเจ็กต์และทำตามรูปแบบนี้ /assets/tagmanager/GTM-XXXX ที่ชื่อไฟล์แสดงถึงรหัสคอนเทนเนอร์ของคุณ

ในกรณีที่มีไฟล์ JSON และไฟล์คอนเทนเนอร์แบบไบนารี SDK จะใช้ไฟล์คอนเทนเนอร์แบบไบนารีเป็นคอนเทนเนอร์เริ่มต้น

การใช้มาโครการเรียกฟังก์ชัน

มาโครการเรียกฟังก์ชันคือมาโครที่ตั้งค่าผลลัพธ์เป็นฟังก์ชันที่ระบุในแอปพลิเคชันของคุณ มาโครการเรียกฟังก์ชันสามารถใช้เพื่อใส่ค่ารันไทม์กับกฎ 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.
        }
      }
    });
    

การตั้งค่าระยะเวลารีเฟรชที่กำหนดเอง

Google Tag Manager SDK จะพยายามเรียก คอนเทนเนอร์ใหม่หากอายุคอนเทนเนอร์ปัจจุบันเกิน 12 ชั่วโมง หากต้องการตั้งค่าระยะเวลารีเฟรชคอนเทนเนอร์ที่กำหนดเอง ให้ใช้ 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);