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