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

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

บทนำ

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

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

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

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

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

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

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

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

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

หากคุณเพิ่งเริ่มใช้ Google Tag Manager เราขอแนะนำให้ดูข้อมูลเพิ่มเติมเกี่ยวกับคอนเทนเนอร์ มาโคร และกฎ (ศูนย์ช่วยเหลือ) ก่อนที่จะอ่านคู่มือนี้ต่อ

เริ่มต้นใช้งาน

ส่วนนี้จะแนะนำนักพัฒนาแอปเกี่ยวกับเวิร์กโฟลว์ Tag Manager ทั่วไป ดังนี้

  1. เพิ่ม SDK ของ Google Tag Manager ลงในโปรเจ็กต์
  2. ตั้งค่าคอนเทนเนอร์เริ่มต้น
  3. เปิดคอนเทนเนอร์
  4. รับค่าการกำหนดค่าจากคอนเทนเนอร์
  5. พุชเหตุการณ์ไปยัง DataLayer
  6. แสดงตัวอย่างและนำคอนเทนเนอร์ไปใช้จริง

1. การเพิ่ม SDK ของ Google Tag Manager ลงในโปรเจ็กต์

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

ตัวเลือกขั้นสูงสำหรับการเปิดคอนเทนเนอร์

SDK ของ Google Tag Manager มีหลายวิธีในการเปิดคอนเทนเนอร์ ซึ่งช่วยให้คุณควบคุมกระบวนการโหลดได้มากขึ้น ดังนี้

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() จะเรียกใช้ Lifecycle Callback หลายรายการเพื่อให้โค้ดของคุณทราบว่าคำขอโหลดเริ่มต้นเมื่อใด ไม่ว่าจะล้มเหลวหรือสำเร็จและสาเหตุ และคอนเทนเนอร์โหลดจากดิสก์หรือเครือข่ายในท้ายที่สุดหรือไม่

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

TagManager.openContainer() จะส่งค่า enum ต่อไปนี้เป็นอาร์กิวเมนต์ไปยัง Callback เหล่านี้

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() ได้ทุกเมื่อเพื่อบังคับให้ส่งคำขอคอนเทนเนอร์เครือข่าย

เมธอดอำนวยความสะดวกทั้ง 2 รายการนี้เป็นแบบไม่บล็อก ContainerOpener.openContainer(..., Long timeoutInMillis) แสดงผลออบเจ็กต์ ContainerOpener.ContainerFuture ซึ่งเมธอด get จะแสดงผล Container ทันทีที่โหลดเสร็จ (แต่จะบล็อกจนกว่าจะถึงตอนนั้น) เมธอด ContainerOpener.openContainer(..., Notifier notifier) จะใช้ Callback เดียว ซึ่งจะเรียกใช้เมื่อคอนเทนเนอร์พร้อมใช้งาน และสามารถใช้เพื่อป้องกันการบล็อกชุดข้อความหลักได้ ทั้ง 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.
        }
      }
    });

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

SDK ของ Google Tag Manager จะพยายามดึงข้อมูลคอนเทนเนอร์ใหม่หากคอนเทนเนอร์ปัจจุบันมีอายุเกิน 12 ชั่วโมง หากต้องการตั้งค่าระยะเวลาการรีเฟรชคอนเทนเนอร์ที่กำหนดเอง ให้ใช้ Timer ดังตัวอย่างต่อไปนี้

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

การแก้ไขข้อบกพร่องด้วย Logger

SDK ของ Google Tag Manager จะพิมพ์ข้อผิดพลาดและคำเตือนลงในบันทึกโดยค่าเริ่มต้น การเปิดใช้การบันทึกแบบละเอียดมากขึ้นอาจเป็นประโยชน์สำหรับการแก้ไขข้อบกพร่อง และทำได้โดยใช้ 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 ของ Logger ที่มีอยู่โดยใช้ 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);