คู่มือนักพัฒนาซอฟต์แวร์นี้จะอธิบายวิธีติดตั้งใช้งาน Google Tag Manager ใน แอปพลิเคชันบนอุปกรณ์เคลื่อนที่
บทนำ
Google Tag Manager ช่วยให้นักพัฒนาซอฟต์แวร์เปลี่ยนการกำหนดค่าได้ ในแอปพลิเคชันบนอุปกรณ์เคลื่อนที่โดยใช้ Google Tag Manager อินเทอร์เฟซโดยไม่ต้องสร้างและส่งไบนารีของแอปพลิเคชันไปยังแอปอีกครั้ง มาร์เก็ตเพลส
ซึ่งจะมีประโยชน์ในการจัดการค่าของการกำหนดค่า หรือ Flag ในแอปพลิเคชัน ที่คุณอาจต้องเปลี่ยนแปลงในอนาคต ซึ่งรวมถึง
- การตั้งค่า UI ต่างๆ และสตริงที่แสดง
- ขนาด สถานที่ตั้ง หรือประเภทของโฆษณาที่แสดงในแอปพลิเคชันของคุณ
- การตั้งค่าเกม
นอกจากนี้ ยังอาจประเมินค่าการกำหนดค่าขณะรันไทม์โดยใช้กฎ การเปิดใช้การกำหนดค่าแบบไดนามิก เช่น
- การใช้ขนาดหน้าจอเพื่อกำหนดขนาดของแบนเนอร์โฆษณา
- การใช้ภาษาและตำแหน่งเพื่อกำหนดค่าองค์ประกอบ UI
Google Tag Manager ยังเปิดใช้การใช้แท็กติดตามแบบไดนามิก และพิกเซลในแอปพลิเคชัน นักพัฒนาแอปสามารถพุชเหตุการณ์สำคัญลงในข้อมูล และตัดสินใจในภายหลังว่าควรเริ่มการทำงานของแท็กหรือพิกเซลการติดตามใด ปัจจุบัน Tag Manager รองรับแท็กต่อไปนี้
- Analytics สำหรับแอปบนมือถือของ Google
- แท็กการเรียกฟังก์ชันที่กำหนดเอง
ก่อนที่คุณจะเริ่ม
ก่อนใช้คู่มือเริ่มต้นใช้งานนี้ คุณจะต้องมีสิ่งต่อไปนี้
- บัญชี Google Tag Manager
- เครื่องจัดการแท็กใหม่ คอนเทนเนอร์และมาโครคอลเล็กชันค่า
- แอปพลิเคชันบนอุปกรณ์เคลื่อนที่สำหรับ Android ที่ใช้ Google Tag Manager
- บริการ Google Analytics SDK ซึ่งมีไลบรารี Tag Manager
หากคุณเพิ่งเริ่มใช้ Google Tag Manager เราขอแนะนำให้คุณ ดูข้อมูลเพิ่มเติมเกี่ยวกับคอนเทนเนอร์ มาโคร และกฎ (ศูนย์ช่วยเหลือ) ก่อนดำเนินการต่อในคู่มือนี้
เริ่มต้นใช้งาน
ส่วนนี้จะแนะนำนักพัฒนาเกี่ยวกับเวิร์กโฟลว์ทั่วไปของเครื่องจัดการแท็ก ดังนี้
- เพิ่ม SDK ของ Google Tag Manager ลงในโปรเจ็กต์
- ตั้งค่าคอนเทนเนอร์เริ่มต้น
- เปิดคอนเทนเนอร์
- รับการกำหนดค่าจากคอนเทนเนอร์
- พุชเหตุการณ์ไปยังชั้นข้อมูล
- ดูตัวอย่างและ นำคอนเทนเนอร์ไปใช้จริง
1. การเพิ่ม SDK ของ Google Tag Manager ลงในโปรเจ็กต์ของคุณ
ก่อนที่จะใช้ SDK ของ Google เครื่องจัดการแท็ก คุณจะต้องแตกไฟล์ 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 ใช้คอนเทนเนอร์เริ่มต้นในการเรียกใช้แอปพลิเคชันครั้งแรก ค่าเริ่มต้น จนกว่าแอปจะสามารถเรียกคอนเทนเนอร์ใหม่ทับ เครือข่าย
หากต้องการดาวน์โหลดและเพิ่มไบนารีของคอนเทนเนอร์เริ่มต้นลงในแอปพลิเคชัน ให้ทำตามขั้นตอนต่อไปนี้
- ลงชื่อเข้าใช้อินเทอร์เฟซเว็บของ Google Tag Manager
- เลือกเวอร์ชันของคอนเทนเนอร์ที่ต้องการดาวน์โหลด
- คลิกปุ่มดาวน์โหลดเพื่อดึงข้อมูลไบนารีของคอนเทนเนอร์
- เพิ่มไฟล์ไบนารีลงใน
เส้นทางต่อไปนี้
<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 ชั่วโมง
การเรียกจะเป็นการตั้งเวลาคำขอเพื่อดึงคอนเทนเนอร์ใหม่แบบไม่พร้อมกัน
ผ่านทางเครือข่าย
การใช้งานตัวอย่างนี้แสดงให้เห็นวิธีที่ง่ายที่สุดในการเปิดและเรียกข้อมูล
ค่าจากคอนเทนเนอร์โดยใช้ Convenience Class ของ 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 เริ่มทำงานได้ และติดตามการโทรเพื่อตอบสนองต่อการดูหน้าจอเหล่านั้นได้โดยไม่ต้อง เขียนโค้ดลงในแอป
ระบบจะพุชเหตุการณ์ไปยังชั้นข้อมูลโดยใช้ 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 ตัวอย่างใน
เว็บอินเทอร์เฟซของ Tag Manager โดยเลือกเวอร์ชันของคอนเทนเนอร์
ที่ต้องการดูตัวอย่าง แล้วเลือกPreview รอต่อ
URL ตัวอย่างนี้เพราะจะต้องใช้ในขั้นตอนถัดไป
จากนั้น เพิ่มกิจกรรมต่อไปนี้ลงใน
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 เครื่องจัดการแท็กสำหรับอุปกรณ์เคลื่อนที่มีการกำหนดค่าขั้นสูงจำนวนหนึ่ง ตัวเลือกที่ให้คุณเลือกค่าตามเงื่อนไขรันไทม์โดยใช้ รีเฟรชคอนเทนเนอร์ด้วยตนเอง และรับตัวเลือกเพิ่มเติมสำหรับการเปิด คอนเทนเนอร์ ส่วนต่อไปนี้จะอธิบายถึงขั้นตอนขั้นสูงหลายอย่างที่พบได้บ่อย การกำหนดค่าเอง
ตัวเลือกขั้นสูงสำหรับการเปิดคอนเทนเนอร์
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() รายการตลอดกระบวนการโหลด
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) จะได้รับการเรียกกลับเพียงครั้งเดียว
เรียกใช้เมื่อคอนเทนเนอร์พร้อมใช้งาน
ซึ่งสามารถใช้เพื่อป้องกันการบล็อกเทรดหลัก
ทั้ง 2 วิธีมีระยะหมดเวลาเริ่มต้นคือ
2000 มิลลิวินาที
การประเมินมาโครในรันไทม์โดยใช้กฎ
คอนเทนเนอร์จะประเมินค่าขณะรันไทม์ได้โดยใช้กฎ อาจอิงตามกฎ ตามเกณฑ์ เช่น ภาษาของอุปกรณ์ แพลตฟอร์ม หรือค่ามาโครอื่นๆ สำหรับ เช่น คุณสามารถใช้กฎเพื่อเลือกสตริงที่แสดงที่แปลแล้วตาม ภาษาของอุปกรณ์ขณะรันไทม์ ซึ่งสามารถกำหนดค่าได้โดยใช้ กฎต่อไปนี้
จากนั้นคุณจะสร้างมาโครการเก็บรวบรวมค่าสําหรับแต่ละภาษา และเพิ่มกฎนี้ลงในมาโครแต่ละรายการได้โดยแทรกโค้ดภาษาที่เหมาะสม เมื่อคอนเทนเนอร์นี้ ได้รับการเผยแพร่แล้ว แอปพลิเคชันของคุณจะสามารถแสดง หน้าจอที่แปลเป็นภาษาท้องถิ่น ขึ้นอยู่กับภาษาอุปกรณ์ของผู้ใช้ขณะรันไทม์
โปรดทราบว่าหากคอนเทนเนอร์เริ่มต้นต้องมีกฎ คุณต้องใช้ ไฟล์คอนเทนเนอร์ไบนารีเป็นค่าเริ่มต้น คอนเทนเนอร์
ดูข้อมูลเพิ่มเติมเกี่ยวกับการกำหนดค่ากฎ (ศูนย์ช่วยเหลือ)
ไฟล์คอนเทนเนอร์เริ่มต้นแบบไบนารี
คอนเทนเนอร์เริ่มต้นที่ต้องใช้กฎควรใช้ไฟล์คอนเทนเนอร์แบบไบนารีแทนไฟล์ JSON เป็นคอนเทนเนอร์เริ่มต้น คอนเทนเนอร์ไบนารีรองรับการพิจารณา ขณะรันไทม์ด้วยกฎ Google Tag Manager ขณะที่ JSON ไม่ให้เข้าถึง
คุณสามารถดาวน์โหลดไฟล์คอนเทนเนอร์ไบนารีได้จากเว็บ Google Tag Manager
อินเทอร์เฟซและ
ควรเพิ่มลงใน
/assets/tagmanager/ โฟลเดอร์และใช้รูปแบบนี้
/assets/tagmanager/GTM-XXXX โดยที่ชื่อไฟล์แสดงถึง
รหัสคอนเทนเนอร์
ในกรณีที่ไฟล์ JSON และมีไฟล์คอนเทนเนอร์ไบนารี SDK จะใช้คอนเทนเนอร์ไบนารี เป็นคอนเทนเนอร์เริ่มต้น
การใช้มาโครการเรียกใช้ฟังก์ชัน
มาโครการเรียกฟังก์ชัน คือมาโครที่ถูกตั้งค่าเป็นค่าส่งคืนของ ฟังก์ชันที่ระบุในแอปพลิเคชัน มาโครการเรียกใช้ฟังก์ชันสามารถใช้เพื่อ รวมค่ารันไทม์กับกฎ Google Tag Manager เช่น กำหนดราคาที่จะแสดงต่อผู้ใช้ขณะรันไทม์ตามที่กำหนดค่าไว้ ภาษาและสกุลเงินของอุปกรณ์
วิธีกำหนดค่ามาโครการเรียกใช้ฟังก์ชัน
- กำหนดมาโครการเรียกใช้ฟังก์ชันในอินเทอร์เฟซเว็บของ Google เครื่องจัดการแท็ก คุณกำหนดค่าอาร์กิวเมนต์เป็นคู่คีย์-ค่าได้
- ลงทะเบียน
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
วิธีกำหนดค่าแท็กการเรียกใช้ฟังก์ชัน
- กำหนดแท็กการเรียกฟังก์ชันในอินเทอร์เฟซเว็บของ Google เครื่องจัดการแท็ก คุณกำหนดค่าอาร์กิวเมนต์เป็นคู่คีย์-ค่าได้
- ลงทะเบียนเครื่องจัดการแท็กการเรียกใช้ฟังก์ชันในแอปพลิเคชันของคุณโดยใช้
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>);
การแก้ไขข้อบกพร่องด้วย Logger
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);