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