เพิ่มประสิทธิภาพการผสานรวมการเรียกเก็บเงินของ Play ให้ได้สูงสุด

เพิ่มประสิทธิภาพการผสานรวมการเรียกเก็บเงินของ Play ให้ได้สูงสุด

เกี่ยวกับ Codelab นี้

subjectอัปเดตล่าสุดเมื่อ ก.ค. 3, 2025
account_circleเขียนโดย Fangyi Luo, Steven Natiello

1 ภาพรวม

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

เราจะช่วยคุณตั้งค่าการแจ้งเตือนแบบเรียลไทม์สำหรับนักพัฒนาแอป (RTDN) และ Play Billing Lab สำหรับการสมัครใช้บริการและไอเทมแบบเรียกเก็บเงินครั้งเดียวสำหรับแอปและเกม คุณจะได้เรียนรู้วิธีลดการเลิกใช้งานของสมาชิก ป้องกันการประพฤติมิชอบและการละเมิด ทดสอบกรณีขอบเขต จำลอง จำลองซ้ำ และแก้ไขปัญหาที่อาจเกิดขึ้น รวมถึงทดสอบข้อเสนอและการเปลี่ยนแปลงราคาโดยไม่ส่งผลกระทบต่อผู้ใช้

เมื่อจบหลักสูตร คุณจะพร้อมใช้กลยุทธ์การดึงดูดผู้ใช้ให้กลับมา แก้ปัญหาการผสานรวมได้อย่างรวดเร็ว เพิ่ม ROI มอบประสบการณ์การใช้งานระดับพรีเมียม และเปิดตัวแอปและการอัปเดตได้อย่างมั่นใจ

ข้อกำหนดเบื้องต้น

สิ่งที่คุณจะได้เรียนรู้

  • วิธีจัดการวงจรการซื้ออย่างเหมาะสมเพื่อช่วยเพิ่มประสิทธิภาพการเติบโตด้วยเทคนิคต่างๆ เพื่อปรับปรุง Conversion การซื้อและการคงลูกค้าไว้
  • วิธีตั้งค่าการแจ้งเตือนแบบเรียลไทม์สำหรับนักพัฒนาแอป (RTDN) โดยใช้ Google Cloud Pub/Sub ซึ่งสามารถใช้ประโยชน์เพื่อติดตั้งใช้งานแคมเปญการได้ผู้ใช้กลับมาและกลยุทธ์การจัดการวงจรอื่นๆ
  • วิธีตั้งค่าผู้รับในเซิร์ฟเวอร์แบ็กเอนด์เพื่อจัดการการแจ้งเตือนอย่างปลอดภัยด้วยการติดตามและการให้สิทธิ์ที่ถูกต้องเพื่อลดการคืนเงินที่ไม่ตั้งใจหรือความเสี่ยงจากการประพฤติมิชอบและการละเมิด
  • วิธีทดสอบการผสานรวมและจำลองข้อผิดพลาดโดยใช้ Play Billing Lab เพื่อปรับปรุงประสบการณ์ของผู้ใช้ไปพร้อมกับลดต้นทุนการพัฒนา

สิ่งที่คุณต้องมี

  • สิทธิ์เข้าถึงบัญชีนักพัฒนาแอป Play สำหรับแอปของคุณใน Google Play Console
  • สิทธิ์เข้าถึงโปรเจ็กต์ Google Cloud Platform ที่เปิดใช้ Google Play Developer API
  • เซิร์ฟเวอร์แบ็กเอนด์สำหรับจัดการบัญชีและการให้สิทธิ์สำหรับแอป Android
  • ผู้ทดสอบใบอนุญาตที่ลงทะเบียนสำหรับแอปของคุณใน Play Developer Console
  • ติดตั้ง Play Billing Lab ในอุปกรณ์ทดสอบ

2 กลยุทธ์การสร้างรายได้สำหรับการสมัครใช้บริการและการซื้อแบบครั้งเดียว

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

ขั้นตอนการซื้อทั่วไปสำหรับการซื้อหรือสมัครใช้บริการแบบครั้งเดียวจะมีหลายระยะดังนี้

  1. ผู้ใช้เลือกดูสินค้าที่จะซื้อ
  2. เปิดขั้นตอนการซื้อเพื่อให้ผู้ใช้ทำการซื้อและชำระเงินให้เสร็จสมบูรณ์
  3. แจ้งเซิร์ฟเวอร์เกี่ยวกับการซื้อที่เสร็จสมบูรณ์
  4. ยืนยันการซื้อในเซิร์ฟเวอร์
  5. มอบเนื้อหาให้ผู้ใช้
  6. ยอมรับการนำส่งเนื้อหา สำหรับผลิตภัณฑ์ที่ใช้แล้วหมดไป ให้ใช้การซื้อในเวลาที่เหมาะสมเพื่อให้ผู้ใช้ซื้อไอเทมนั้นอีกครั้งได้

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

การแจ้งเตือนแบบเรียลไทม์สำหรับนักพัฒนาแอป (RTDN) เป็นวิธีที่ยอดเยี่ยมในการจดจำขั้นตอนต่างๆ ในวงจรการซื้อ และสามารถใช้เป็นทั้งเครื่องมือติดตามประสิทธิภาพแบบเรียลไทม์และเครื่องมือที่เปิดใช้กลยุทธ์การดึงดูดสมาชิกให้กลับมาได้อย่างมีประสิทธิภาพ

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

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

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

3 กำหนดค่าการแจ้งเตือนแบบเรียลไทม์สำหรับนักพัฒนาแอป (RTDN)

การแจ้งเตือนแบบเรียลไทม์สำหรับนักพัฒนาแอป (RTDN) ใช้ประโยชน์จาก Google Cloud Pub/Sub เพื่อให้คุณดำเนินการกับการเปลี่ยนแปลงสถานะการซื้อได้ทันที Cloud Pub/Sub เป็นบริการรับส่งข้อความแบบเรียลไทม์ที่มีการจัดการโดยสมบูรณ์ซึ่งคุณใช้ส่งและรับข้อความระหว่างแอปพลิเคชันอิสระได้ Google Play ใช้ Cloud Pub/Sub เพื่อเผยแพร่การแจ้งเตือนแบบพุชในหัวข้อที่คุณสมัครรับข้อมูล

หากต้องการเปิดใช้ RTDN ก่อนอื่นคุณต้องตั้งค่า Cloud Pub/Sub โดยใช้โปรเจ็กต์ Google Cloud Platform (GCP) ของคุณเอง จากนั้นเปิดใช้การแจ้งเตือนสําหรับแอป หากคุณไม่คุ้นเคยกับ GCP และ Cloud Pub/Sub โปรดดูคู่มือเริ่มต้นใช้งานอย่างรวดเร็ว

สร้างหัวข้อ

หากต้องการเริ่มรับการแจ้งเตือน คุณต้องสร้างหัวข้อที่ Google Play ควรเผยแพร่การแจ้งเตือน หากต้องการสร้างหัวข้อ ให้ทําตามวิธีการในหัวข้อสร้างหัวข้อ

สร้างการสมัครใช้บริการ Pub/Sub

หากต้องการรับข้อความที่เผยแพร่ไปยังหัวข้อ คุณต้องสร้างการสมัครใช้บริการ Pub/Sub ให้กับหัวข้อนั้น วิธีสร้างการสมัครใช้บริการ Pub/Sub

  1. อ่านคู่มือผู้สมัครใช้บริการ Cloud Pub/Sub เพื่อให้คุ้นเคยกับวิธีกำหนดค่าการสมัครใช้บริการเป็นการสมัครใช้บริการแบบพุชหรือการสมัครใช้บริการแบบพุล ในโค้ดแล็บนี้ เราจะทํางานกับการสมัครใช้บริการแบบดึงซึ่งกำหนดให้เซิร์ฟเวอร์แบ็กเอนด์ที่ปลอดภัยของคุณต้องส่งคำขอไปยังเซิร์ฟเวอร์ Cloud Pub/Sub เพื่อดึงข้อมูลข้อความ
  1. ทำตามวิธีการในหัวข้อเพิ่มการสมัครใช้บริการเพื่อสร้างการสมัครใช้บริการ

ให้สิทธิ์เผยแพร่ในหัวข้อของคุณ

Cloud Pub/Sub กำหนดให้คุณให้สิทธิ์ Google Play เผยแพร่การแจ้งเตือนในหัวข้อของคุณ

  1. เปิด Google Cloud Console
  2. เลือกโปรเจ็กต์ แล้วค้นหา "Pub/Sub" ในแถบค้นหา แล้วไปที่หน้าการกําหนดค่า Pub/Sub ค้นหาและไปที่หน้าการกําหนดค่า Pub/Sub
  3. ค้นหาหัวข้อ แล้วเปิดการตั้งค่าสิทธิ์ เปิดการตั้งค่าสิทธิ์
  4. คลิกเพิ่มผู้ใช้หลักเพื่อเพิ่มบัญชีบริการ google-play-developer-notifications@system.gserviceaccount.com และมอบหมายบทบาทผู้เผยแพร่ Pub/Sub เพิ่มบัญชีบริการ google-play-developer-notifications@system.gserviceaccount.com และมอบหมายบทบาทผู้เผยแพร่ Pub/Sub ให้กับบัญชีดังกล่าว
  5. คลิกบันทึกเพื่อตั้งค่าหัวข้อให้เสร็จสมบูรณ์ คลิก "บันทึก" เพื่อตั้งค่าหัวข้อให้เสร็จสมบูรณ์

เปิดใช้ RTDN สําหรับแอป

ดูวิธีตั้งค่าการแจ้งเตือนแบบเรียลไทม์สำหรับนักพัฒนาแอป (RTDN) เพื่อปรับปรุงการผสานรวม Play Billing ให้ดียิ่งขึ้น คุณสามารถปรับปรุงความน่าเชื่อถือของการซื้อด้วยการรับส่งข้อความที่ปรับเปลี่ยนในแบบของคุณ และป้องกันการประพฤติมิชอบและการละเมิดเพื่อเพิ่ม ROI โดยรวม

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

วิธีเปิดใช้การแจ้งเตือนแบบเรียลไทม์สำหรับนักพัฒนาแอป

  1. เปิด Google Play Console
  2. เลือกแอป
  3. ไปที่สร้างรายได้ด้วย Play > การตั้งค่าการสร้างรายได้
  4. เลื่อนไปที่ส่วนการแจ้งเตือนแบบเรียลไทม์สำหรับนักพัฒนาแอป
  5. เลือกเปิดใช้การแจ้งเตือนแบบเรียลไทม์
  6. ในช่องชื่อหัวข้อ ให้ป้อนชื่อหัวข้อ Cloud Pub/Sub แบบเต็มที่คุณกําหนดค่าไว้ก่อนหน้านี้ ชื่อหัวข้อต้องอยู่ในรูปแบบ projects/{project_id}/topics/{topic_name} โดยที่ project_id เป็นตัวระบุที่ไม่ซ้ำกันสำหรับโปรเจ็กต์ และ topic_name คือชื่อหัวข้อที่สร้างไว้ก่อนหน้านี้
  7. คลิกส่งข้อความทดสอบเพื่อส่งข้อความทดสอบ การเผยแพร่แบบทดสอบช่วยให้มั่นใจได้ว่าทุกอย่างได้รับการตั้งค่าและกำหนดค่าอย่างถูกต้อง หากเผยแพร่การทดสอบสําเร็จ ระบบจะแสดงข้อความว่าเผยแพร่การทดสอบสําเร็จ หากแนบการสมัครรับข้อมูลของหัวข้อนี้ไว้ คุณจะได้รับข้อความทดสอบ สำหรับการสมัครใช้บริการแบบดึง ให้ไปที่การสมัครใช้บริการใน Cloud Console แล้วคลิกดูข้อความ จากนั้นดึงข้อความ คุณควรรับทราบข้อความที่ดึงมาเพื่อหลีกเลี่ยงการส่งซ้ำโดย Cloud Pub/Sub สําหรับการสมัครใช้บริการ Push ให้ตรวจสอบว่าระบบส่งข้อความทดสอบไปยังปลายทาง Push หรือไม่ รหัสการตอบกลับที่สำเร็จจะเป็นข้อความรับทราบ หากเผยแพร่ไม่สำเร็จ ระบบจะแสดงข้อผิดพลาด ตรวจสอบว่าชื่อหัวข้อถูกต้องและบัญชีบริการ google-play-developer-notifications@system.gserviceaccount.com มีสิทธิ์เข้าถึงผู้เผยแพร่โฆษณา Pub/Sub ในหัวข้อ
  8. เลือกประเภทการแจ้งเตือนที่ต้องการรับ
  • รับการแจ้งเตือนสำหรับการสมัครใช้บริการและการซื้อที่เป็นโมฆะทั้งหมด - รับการแจ้งเตือนแบบเรียลไทม์สำหรับนักพัฒนาแอปที่เกี่ยวข้องกับการสมัครใช้บริการและการซื้อที่เป็นโมฆะ คุณจะไม่ได้รับแจ้งเกี่ยวกับการซื้อผลิตภัณฑ์แบบครั้งเดียว
  • รับการแจ้งเตือนทั้งหมดสำหรับการสมัครใช้บริการและผลิตภัณฑ์แบบเรียกเก็บเงินครั้งเดียว - รับการแจ้งเตือนสำหรับกิจกรรมการสมัครใช้บริการและการซื้อที่เป็นโมฆะทั้งหมด นอกจากนี้ คุณยังจะได้รับเหตุการณ์การซื้อผลิตภัณฑ์แบบเรียกเก็บเงินครั้งเดียว เช่น ONE_TIME_PRODUCT_PURCHASED และ ONE_TIME_PRODUCT_CANCELED ดูข้อมูลเพิ่มเติมเกี่ยวกับเหตุการณ์การซื้อเหล่านี้ได้ที่วงจรการซื้อแบบครั้งเดียว

a266e5dec5c93cd8.png

  1. คลิกบันทึกการเปลี่ยนแปลง

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

4 รับการแจ้งเตือน

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

ซึ่งจำเป็นต้องตรวจหาและประมวลผลการซื้อให้เสร็จสมบูรณ์อย่างทันท่วงที Play Billing Library มีวิธีต่างๆ ในการตรวจหาการซื้อในแอป เมื่อตรวจพบการซื้อที่เสร็จสมบูรณ์แล้ว แอปของคุณต้องแจ้งให้เซิร์ฟเวอร์แบ็กเอนด์ยืนยันการซื้อ ให้เนื้อหาแก่ผู้ใช้ที่ถูกต้อง แล้วแจ้งให้ Google ทราบว่าดำเนินการซื้อแล้ว อย่างไรก็ตาม แอปอาจไม่ตรวจพบการซื้อในเวลาที่เหมาะสมเนื่องจากสาเหตุหลายประการ เช่น ผู้ใช้ซื้อสำเร็จและได้รับการยืนยันจาก Google แต่อุปกรณ์ของผู้ใช้ขาดการเชื่อมต่อเครือข่ายก่อนที่อุปกรณ์และแอปของคุณจะได้รับการแจ้งเตือนผ่านอินเทอร์เฟซ Google Play Billing Library RTDN มีการควบคุมเพิ่มเติมฝั่งเซิร์ฟเวอร์เพื่อช่วยคุณจัดการการซื้อได้แม้ว่าไคลเอ็นต์ของผู้ใช้จะมีปัญหาก็ตาม RTDN รับประกันการแจ้งเตือนไปยังเซิร์ฟเวอร์ของคุณอย่างอิสระเมื่อสถานะการซื้อมีการเปลี่ยนแปลง ซึ่งจะช่วยให้คุณทราบการเปลี่ยนแปลงสถานะการซื้อได้เกือบจะทันทีผ่านเส้นทางที่ 2 โดยไม่ขึ้นอยู่กับปัญหาที่อาจเกิดขึ้นกับไคลเอ็นต์ เพื่อให้กระบวนการซื้อมีความน่าเชื่อถือมากขึ้น

ในส่วนนี้ คุณจะต้องสร้างผู้สมัครใช้บริการเพื่อรับข้อความที่ส่งไปยังหัวข้อ Cloud Pub/Sub โดยใช้ไลบรารีไคลเอ็นต์ Cloud Pub/Sub ไลบรารีเหล่านี้มีให้บริการในหลายภาษา ในส่วนต่อไปนี้ เราจะเพิ่มข้อมูลไปยังผู้สมัครใช้บริการเพื่อยืนยันการซื้อ ให้สิทธิ์แก่ผู้ใช้ที่ถูกต้อง และรับทราบ/ใช้การซื้อในเซิร์ฟเวอร์ เราจะใช้ Java ในโค้ดแล็บนี้

การเผยแพร่แต่ละรายการไปยังหัวข้อ Cloud Pub/Sub จะมีช่องข้อมูลที่เข้ารหัสฐาน 64 ช่องเดียว

{
 "message": {
   "attributes": {
     "key": "value"
   },
   "data": "eyAidmVyc2lvbiI6IHN0cmluZywgInBhY2thZ2VOYW1lIjogc3RyaW5nLCAiZXZlbnRUaW1lTWlsbGlzIjogbG9uZywgIm9uZVRpbWVQcm9kdWN0Tm90aWZpY2F0aW9uIjogT25lVGltZVByb2R1Y3ROb3RpZmljYXRpb24sICJzdWJzY3JpcHRpb25Ob3RpZmljYXRpb24iOiBTdWJzY3JpcHRpb25Ob3RpZmljYXRpb24sICJ0ZXN0Tm90aWZpY2F0aW9uIjogVGVzdE5vdGlmaWNhdGlvbiB9",
   "messageId": "136969346945"
 },
 "subscription": "projects/myproject/subscriptions/mysubscription"
}

หลังจากถอดรหัสช่องข้อมูลที่เข้ารหัส Base64 แล้ว DeveloperNotification จะมีช่องต่อไปนี้

{
 "version": string,
 "packageName": string,
 "eventTimeMillis": long,
 "oneTimeProductNotification": OneTimeProductNotification,
 "subscriptionNotification": SubscriptionNotification,
 "voidedPurchaseNotification": VoidedPurchaseNotification,
 "testNotification": TestNotification
}

โปรดดูข้อมูลเพิ่มเติมในข้อมูลอ้างอิงเกี่ยวกับการแจ้งเตือนแบบเรียลไทม์สำหรับนักพัฒนาแอป

ต่อไปนี้คือโค้ดตัวอย่างของ NotificationReceiver สำหรับเซิร์ฟเวอร์แบ็กเอนด์ที่ปลอดภัยเพื่อประมวลผลข้อความ Pub/Sub หากต้องการตรวจสอบสิทธิ์กับศูนย์บัญชาการการรักษาความปลอดภัย ให้ตั้งค่าข้อมูลเข้าสู่ระบบเริ่มต้นของแอปพลิเคชัน โปรดดูตั้งค่าการตรวจสอบสิทธิ์สําหรับสภาพแวดล้อมการพัฒนาในเครื่อง

import com.google.cloud.pubsub.v1.AckReplyConsumer;
import com.google.cloud.pubsub.v1.MessageReceiver;
import com.google.cloud.pubsub.v1.Subscriber;
import com.google.pubsub.v1.ProjectSubscriptionName;
import com.google.pubsub.v1.PubsubMessage;
import java.util.Base64;
import org.json.JSONObject;

/** Real-time developer notifications receiver. */
public class NotificationReceiver {

 private NotificationReceiver() {}

 /*
  * Receive notification messages from the subscription.
  *
  * @param projectId The project ID of your Google Cloud Project.
  * @param subscriptionId The subscription ID of the subscriber to the pub/sub topic.
  */
 public static void receiveNotificationMessages(String projectId, String subscriptionId) {
   ProjectSubscriptionName subscriptionName =
       ProjectSubscriptionName.of(projectId, subscriptionId);

   try {
     Subscriber subscriber =
         Subscriber.newBuilder(subscriptionName, new NotificationMessageReceiver()).build();
     // Start the subscriber.
     subscriber.startAsync().awaitRunning();

     subscriber.awaitTerminated();
   } catch (IllegalStateException e) {
     System.out.println("Subscriber stopped: " + e);
   }
 }

 static class NotificationMessageReceiver implements MessageReceiver {

   @Override
   public void receiveMessage(PubsubMessage message, AckReplyConsumer consumer) {
     // Decode the data into a String from the message data field.
     String jsonString = new String(Base64.getDecoder().decode(message.getData().toStringUtf8()));
     // Parse the String into a JSON object.
     JSONObject messageJson = new JSONObject(jsonString);

     // Fetch the value for certain fields.
     String version = messageJson.getString("version");
     String packageName = messageJson.getString("packageName");
     System.out.println("version: " + version);
     System.out.println("packageName: " + packageName);

     // Validate the purchase and grant the entitlement as needed.
     // More details in the following sections.
     // ......

     // Acknowledge the message to avoid repeated delivery.
     consumer.ack();
   }
 }
}

ตอนนี้คุณมีเครื่องมือรับการแจ้งเตือนที่ใช้ข้อความที่ส่งไปยังหัวข้อ Cloud Pub/Sub ในเซิร์ฟเวอร์แบ็กเอนด์ที่ปลอดภัย ในส่วนต่อไปนี้ เราจะกล่าวถึงแนวทางปฏิบัติแนะนำในการประมวลผลข้อความ RTDN ในเซิร์ฟเวอร์แบ็กเอนด์

5 แนบตัวระบุผู้ใช้ในขั้นตอนการซื้อในแอป

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

ตัวอย่างต่อไปนี้แสดงโค้ดเพื่อแนบตัวระบุผู้ใช้เมื่อเปิดขั้นตอนการซื้อในแอปโดยการตั้งค่า obfuscatedAccountId

// An activity reference from which the billing flow will be launched.
Activity activity = ...;
// A user identifier, e.g. an obfuscated user id in your system.
String obfuscatedAccountId = ...;

ImmutableList<ProductDetailsParams> productDetailsParamsList =
    ImmutableList.of(
        ProductDetailsParams.newBuilder()
            // retrieve a value for "productDetails" by calling queryProductDetailsAsync()
            .setProductDetails(productDetails)
            // set the offer token to specify the offer to purchase when applicable, e.g., subscription products
            // .setOfferToken(offerToken)
            .build()
    );

BillingFlowParams billingFlowParams = BillingFlowParams.newBuilder()
    .setProductDetailsParamsList(productDetailsParamsList)
    .setObfuscatedAccountId(obfuscatedAccountId)
    .build();

// Launch the billing flow
BillingResult billingResult = billingClient.launchBillingFlow(activity, billingFlowParams);

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

6 ยืนยันการซื้อก่อนให้สิทธิ์

ในส่วนนี้ เราจะกล่าวถึงแนวทางปฏิบัติแนะนำในการยืนยันการซื้อก่อนที่จะให้สิทธิ์ในเซิร์ฟเวอร์แบ็กเอนด์ที่ปลอดภัย

หลังจากผู้ใช้ซื้อไอเทมแบบเรียกเก็บเงินครั้งเดียว ผู้สมัครใช้บริการ Pub/Sub ในเซิร์ฟเวอร์แบ็กเอนด์ที่ปลอดภัยของคุณจะได้รับข้อความ Pub/Sub คุณควรทําดังนี้ในเซิร์ฟเวอร์แบ็กเอนด์

  1. แยกวิเคราะห์ purchaseToken จากข้อความ Pub/Sub คุณควรเก็บบันทึกค่า purchaseToken ทั้งหมดสำหรับการซื้อทั้งหมด
  2. ตรวจสอบว่าค่า purchaseToken สำหรับการซื้อปัจจุบันไม่ตรงกับค่า purchaseToken ก่อนหน้า purchaseToken จะไม่ซ้ำกันทั่วโลก คุณจึงใช้ค่านี้เป็นคีย์หลักในฐานข้อมูลได้อย่างปลอดภัย
  3. ใช้ปลายทาง purchases.products:get ใน Google Play Developer API เพื่อยืนยันกับ Google ว่าการซื้อนั้นถูกต้อง
  1. หากการซื้อนั้นถูกต้องและไม่เคยมีการใช้มาก่อน คุณสามารถให้สิทธิ์เข้าถึงไอเทมที่ซื้อในแอปหรือการสมัครใช้บริการได้อย่างปลอดภัย
  2. คุณควรให้สิทธิ์ก็ต่อเมื่อสถานะการซื้อเป็น PURCHASED และตรวจสอบว่าได้จัดการการซื้อ PENDING อย่างถูกต้อง ดูข้อมูลเพิ่มเติมได้ที่การจัดการธุรกรรมที่รอดำเนินการ

ตัวอย่างโค้ดต่อไปนี้สร้างไคลเอ็นต์ API สําหรับ Google Play Developer API เราจะใช้ข้อมูลนี้เพื่อเรียก API ในภายหลัง

import com.google.api.client.auth.oauth2.Credential;
import com.google.api.client.googleapis.auth.oauth2.GoogleCredential;
import com.google.api.client.googleapis.javanet.GoogleNetHttpTransport;
import com.google.api.client.http.HttpTransport;
import com.google.api.client.json.JsonFactory;
import com.google.api.client.json.gson.GsonFactory;
import com.google.api.services.androidpublisher.AndroidPublisher;
import com.google.api.services.androidpublisher.AndroidPublisherScopes;
import java.io.IOException;
import java.security.GeneralSecurityException;
import java.util.Collections;

/** Helper class to initialize the publisher APIs client library. */
public class AndroidPublisherHelper {
 /* Your application name */
 private static final String APPLICATION_NAME = "YourApplicationName";

 /* Load credentials from a JSON key file. Replace with the actual path to your downloaded service
  * account key file.
  */
 private static final String RESOURCES_CLIENT_SECRETS_JSON =
     "/path/to/your/service_account_key.json";

 /** Global instance of the JSON factory. */
 private static final JsonFactory JSON_FACTORY = GsonFactory.getDefaultInstance();

 /* The API client */
 private static final AndroidPublisher ANDROID_PUBLISHER = init();

 /**
  * Performs all necessary setup steps for running requests against the API.
  *
  * @return the {@link AndroidPublisher} service
  */
 private static AndroidPublisher init(){
   try {
     // Authorization.
     Credential credential =
         GoogleCredential.fromStream(
                 AndroidPublisherHelper.class.getResourceAsStream(RESOURCES_CLIENT_SECRETS_JSON))
             .createScoped(Collections.singleton(AndroidPublisherScopes.ANDROIDPUBLISHER));

     HttpTransport httpTransport = GoogleNetHttpTransport.newTrustedTransport();

     // Set up and return API client.
     return new AndroidPublisher.Builder(httpTransport, JSON_FACTORY, credential)
         .setApplicationName(ApplicationConfig.APPLICATION_NAME)
         .build();
   } catch (GeneralSecurityException | IOException ex) {
     throw new RuntimeException("fail to initialize the publisher APIs client library", ex);
   }
 }
}

จากนั้นเราจะเพิ่มตรรกะในการเรียก API และแก้ไขผู้รับที่สร้างไว้ก่อนหน้านี้เพื่อตรวจสอบการซื้อและมอบสิทธิ์แก่ผู้ใช้ที่ถูกต้อง

ใน AndroidPublisherHelper ให้เพิ่มเมธอดต่อไปนี้เพื่อดึงข้อมูล ProductPurchase จากปลายทาง Purchases.products:get ใน Google Play Developer API

 /* Fetch the ProductPurchase for the one-time product purchase from
  * Purchases.products.get endpoint in the Google Play Developer API
  */
 public static ProductPurchase executeProductPurchasesGet(
     String packageName, String sku, String purchaseToken) {
   try {
     ProductPurchase productPurchase =
         ANDROID_PUBLISHER.purchases().products().get(packageName, sku, purchaseToken).execute();
     return productPurchase;
   } catch (IOException ex) {
     log.error("Exception was thrown while getting a product purchase", ex);
     // It is recommended to apply some retry mechanism, such as exponential backoff, to fetch the purchase in case of transient failures.
     return null;
   }
 }

ใน NotificationMessageReceiver ให้ตรวจสอบการซื้อและมอบสิทธิ์แก่ผู้ใช้ที่ถูกต้องในระบบตามข้อมูลที่ระบุไว้ในการแจ้งเตือน คุณควรติดตาม purchaseToken ในเซิร์ฟเวอร์ต่อไปเพื่อหลีกเลี่ยงการประมวลผลซ้ำ

 @Override
 public void receiveMessage(PubsubMessage message, AckReplyConsumer consumer) {
   // Decode the data into a String from the message data field.
   String jsonString = new String(Base64.getDecoder().decode(message.getData().toStringUtf8()));
   // Parse the String into a JSON object.
   JSONObject messageJson = new JSONObject(jsonString);

   // Fetch the value for certain fields.
   String version = messageJson.getString("version");
   String packageName = messageJson.getString("packageName");

   // Process notification data based on your business requirements.
   // Process oneTimeProductNotification in the message.
   JSONObject oneTimeProductNotificationJson =
       messageJson.getJSONObject("oneTimeProductNotification");
   if (oneTimeProductNotificationJson != null) {
     String purchaseToken = oneTimeProductNotificationJson.getString("purchaseToken");
     String sku = oneTimeProductNotificationJson.getString("sku");
     int notificationType = oneTimeProductNotificationJson.getInt("notificationType");

     if (notificationType == 1) {
       // ONE_TIME_PRODUCT_PURCHASED - A one-time product was successfully purchased by a user.
       // Verify that the purchaseToken value does not match any previous purchaseToken values in
       // your backend system to avoid duplicate processing.
       ......
       // Fetch the ProductPurchase from Purchases.products.get endpoint
       ProductPurchase productPurchase =
         AndroidPublisherHelper.executeProductPurchasesGet(packageName, sku, purchaseToken);
       if (productPurchase != null && productPurchase.getPurchaseState() == 0) {
         // The purchase is valid and in PURCHASED state.

         // The account Id set in the App when launching the billing flow.
         String obfuscatedExternalAccountId = productPurchase.getObfuscatedExternalAccountId();
         // Grant the entitlement to the correct account for obfuscatedExternalAccountId in your
         // system.
       ......
       }
     }
     // Process subscriptionNotification in the message.
     JSONObject subscriptionNotificationJson = messageJson.getJSONObject("subscriptionNotification");
     if (subscriptionNotificationJson != null) {
       ......
     }
     // Process other notification data in the message as needed.
     ......
   }

   // Acknowledge the message to avoid repeated delivery.
   consumer.ack();
 }

7 แจ้งให้ Google ทราบว่ามีการดำเนินการซื้อแล้ว

หลังจากให้สิทธิ์แล้ว คุณควรแจ้งให้ Google ทราบว่ามีการดำเนินการซื้อแล้วโดยการเรียกใช้ปลายทาง purchases.products:consume หรือ purchases.products:acknowledge ใน Play Developer API จากเซิร์ฟเวอร์แบ็กเอนด์ที่ปลอดภัยเพื่อใช้ผลิตภัณฑ์ที่บริโภคได้หรือรับทราบผลิตภัณฑ์ที่บริโภคไม่ได้

ใน AndroidPublisherHelper ให้เพิ่มเมธอดต่อไปนี้เพื่อเรียกใช้ purchases.products:consume หรือ purchases.products:acknowledge ใน Google Play Developer API

 /* Consume the one-time product purchase by calling
  * Purchases.products.consume endpoint in the Google Play Developer API
  */
 public static void executeProductPurchasesConsume(
     String packageName, String sku, String purchaseToken) {
   try {
     ANDROID_PUBLISHER
       .purchases().products().consume(packageName, sku, purchaseToken).execute();
   } catch (IOException ex) {
     log.error("Exception was thrown while consuming a product purchase", ex);
     // It is recommended to apply some retry mechanism, such as exponential backoff, to ensure the purchase is correctly consumed in case of transient failures.
   }
 }

 /* Acknowledge the one-time product purchase by calling
  * Purchases.products.acknowledge endpoint in the Google Play Developer API
  */
 public static void executeProductPurchasesAcknowledge(
     String packageName, String sku, String purchaseToken) {
   try {
     ANDROID_PUBLISHER
       .purchases().products().acknowledge(packageName, sku, purchaseToken, new ProductPurchasesAcknowledgeRequest()).execute();
   } catch (IOException ex) {
     log.error("Exception was thrown while acknowledging a product purchase", ex);
     // It is recommended to apply some retry mechanism, such as exponential backoff, to ensure the purchase is correctly acknowledged in case of transient failures.
   }
 }

ใน NotificationMessageReceiver ให้ใช้การซื้อผลิตภัณฑ์ที่ใช้แล้วหมดไปหรือรับทราบการซื้อผลิตภัณฑ์ที่อยู่ตลอดไปหลังจากให้สิทธิ์ในเซิร์ฟเวอร์แบ็กเอนด์

 @Override
 public void receiveMessage(PubsubMessage message, AckReplyConsumer consumer) {
   ......
       String obfuscatedExternalAccountId = productPurchase.getObfuscatedExternalAccountId();
       // Grant the entitlement to the correct account for obfuscatedExternalAccountId in your
       // system.
       ......
       // If the product is a consumable product, consume the purchase.
       AndroidPublisherHelper.executeProductPurchasesConsume(packageName, sku, purchaseToken);
       // Or if the product is a non-consumable product, acknowledge the purchase.
       // AndroidPublisherHelper.executeProductPurchasesAcknowledge(packageName, sku, purchaseToken);
  ......

 }

คุณต้องรับทราบเนื่องจากเป็นการแจ้งให้ Google Play ทราบว่าผู้ใช้ได้รับสิทธิ์ในการซื้อแล้ว คุณควรรับทราบการซื้อทันทีหลังจากให้สิทธิ์

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

8 ทดสอบด้วย Play Billing Lab

คุณควรทดสอบการผสานรวมตลอดการพัฒนาเพื่อให้มั่นใจว่าพร้อมเปิดตัว Play Billing Lab เป็นแอป Android ที่ไม่มีค่าใช้จ่ายซึ่งช่วยให้นักพัฒนาแอปทดสอบการผสานรวมกับระบบการเรียกเก็บเงินของ Google Play ได้ จึงเป็นวิธีที่ง่ายและสะดวกสำหรับนักพัฒนาแอปในการทดสอบฟีเจอร์ Play Billing ผสานรวมได้เร็วขึ้น และเปิดตัวด้วยความมั่นใจมากขึ้น

Play Billing Lab มีฟีเจอร์การทดสอบที่หลากหลายเพื่อช่วยทดสอบสถานการณ์ต่างๆ ซึ่งรวมถึง

เราเพิ่มความสามารถในการทดสอบใหม่ๆ ลงในแอป Play Billing Lab อย่างต่อเนื่อง คุณสามารถดาวน์โหลดและติดตั้ง Play Billing Lab จาก Play Store หรือดูข้อมูลเพิ่มเติมเกี่ยวกับการทดสอบด้วย Play Billing Lab ได้ที่ทดสอบการผสานรวม

ใช้ Play Billing Lab เพื่อทดสอบ BillingResponseCode

การทดสอบขั้นตอน BillingResponseCode ทั้งหมดเมื่อผสานรวมแอปกับ Play Billing Library เป็นปัญหาที่พบได้ทั่วไป เนื่องจากคุณไม่สามารถควบคุมการสื่อสารระหว่าง Play Store กับแบ็กเอนด์ของ Play ได้ ฟีเจอร์เครื่องมือจำลองการตอบกลับในแอป Play Billing Lab ช่วยให้คุณกำหนดค่าการตอบกลับด้วยโค้ดข้อผิดพลาดสำหรับ Play Billing Library เพื่อทดสอบสถานการณ์ข้อผิดพลาดที่ซับซ้อนต่างๆ ได้

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

ทดสอบด้วยโปรแกรมจำลองการตอบกลับ

เมื่อทดสอบด้วยโปรแกรมจำลองการตอบกลับ แอปจะสื่อสารกับ Play Billing Lab เพื่อรับโค้ดตอบกลับที่คุณกำหนดค่าไว้ในโปรแกรมจำลองการตอบกลับของ Play Billing Lab

เปิดใช้การทดสอบการลบล้างการเรียกเก็บเงินสำหรับไลบรารี Play Billing

หากต้องการเปิดใช้การสื่อสารระหว่างเครื่องจำลองการตอบกลับกับแอป คุณต้องเปิดใช้การทดสอบการลบล้างการเรียกเก็บเงินสำหรับ Play Billing Library จากภายในแอปก่อน โดยเพิ่มแท็กข้อมูลเมตาต่อไปนี้ลงในไฟล์ AndroidManifest.xml ของแอป

<manifest ... >
  <application ... >
    ...
     <meta-data
      android:name="com.google.android.play.largest_release_audience.NONPRODUCTION"
      android:value="" />
    <meta-data
      android:name="com.google.android.play.billingclient.enableBillingOverridesTesting"
      android:value="true" />
  </application>
</manifest>

สร้างแอปด้วยไฟล์ AndroidManifest.xml ที่อัปเดตแล้ว ตอนนี้แอปของคุณพร้อมสำหรับโปรแกรมจำลองการตอบกลับของ Play Billing Lab แล้ว

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

จำลองข้อผิดพลาดของ Play Billing Library

หากต้องการทดสอบด้วยข้อผิดพลาดของ Play Billing Library ที่จำลองไว้ ให้กำหนดค่าโค้ดตอบกลับในแอป Play Billing Lab ก่อน จากนั้นทำการทดสอบในแอป

กำหนดค่าโค้ดตอบกลับ

  1. ลงชื่อเข้าใช้แอป Play Billing Lab ด้วยบัญชีผู้ทดสอบใบอนุญาตสำหรับแอปของคุณ รูปภาพต่อไปนี้แสดงหน้าแดชบอร์ดของ Play Billing Lab รวมถึงการ์ดโปรแกรมจำลองการตอบกลับ

แดชบอร์ด Play Billing Lab ที่มีเครื่องจำลองการตอบกลับ

  1. คลิกจัดการในการ์ดโปรแกรมจำลองการตอบกลับเพื่อไปยังหน้าจอโปรแกรมจำลองการตอบกลับ
  2. เมื่อได้รับข้อความแจ้ง ให้อนุญาตการแจ้งเตือนจาก Play Billing Lab เพื่อดูสถานะการเชื่อมต่อของแอป
  3. เปิดใช้สวิตช์ "จำลองการตอบกลับของ Play Billing Library" หากยังไม่ได้เปิดใช้

c841baa4c96bf306.png

  1. เลือกโค้ดตอบกลับสำหรับ Play Billing Library API ที่ต้องการทดสอบ หากต้องการจำลองข้อผิดพลาดสำหรับการซื้อที่ใช้ ให้เลือกรหัสข้อผิดพลาดสำหรับ consumeAsync api ระบบจะบันทึกรายการที่คุณเลือกไว้โดยอัตโนมัติ ตอนนี้โปรแกรมจำลองการตอบกลับพร้อมที่จะส่งโค้ดตอบกลับที่เลือกไปยังแอปของคุณแล้ว

ทดสอบแอป

ตอนนี้คุณสามารถทดสอบแอปเพื่อยืนยันว่าทุกอย่างทำงานตามที่คาดไว้หรือไม่ในสถานการณ์ข้อผิดพลาดที่กําหนดค่าไว้ เปิดแอปและเรียกใช้เมธอด Play Billing Library API หากแอปของคุณเรียกใช้ consumeAsync เพื่อใช้การซื้อ แอปจะได้รับรหัสข้อผิดพลาดตามที่คุณเพิ่งกําหนดค่าไว้ คุณสามารถตรวจสอบว่าแอปทำงานได้อย่างถูกต้องหรือไม่จากรหัสข้อผิดพลาด และเซิร์ฟเวอร์แบ็กเอนด์ประมวลผลการซื้ออย่างถูกต้องหรือไม่

หลังจากทดสอบเสร็จแล้ว ให้ปิดสวิตช์ "จำลองการตอบกลับของ Play Billing Library" เพื่อหยุดการจำลองการตอบกลับ

ดูข้อมูลเพิ่มเติมเกี่ยวกับการทดสอบด้วย Play Billing Lab หรือไปที่ศูนย์ช่วยเหลือเพื่อดูข้อมูลเพิ่มเติมเกี่ยวกับการทดสอบการเรียกเก็บเงินสำหรับการซื้อในแอปด้วยเครื่องมือทดสอบใบอนุญาต

9 ยินดีด้วย

คุณได้ทํา Codelab นี้เสร็จแล้ว และพร้อมที่จะเพิ่มประสิทธิภาพการสร้างรายได้จากแอปอย่างมีกลยุทธ์เพื่อปรับปรุงประสบการณ์ของผู้ใช้ ซึ่งจะช่วยเพิ่มการปรับปรุงความพึงพอใจของผู้ใช้, Conversion การซื้อ และการเลิกใช้งานของสมาชิก

การใช้การแจ้งเตือนแบบเรียลไทม์สำหรับนักพัฒนาแอปและแอปที่ใช้ร่วมกันของ Play Billing Lab จะช่วยให้คุณจัดการเหตุการณ์ในวงจรการซื้อได้ตั้งแต่เนิ่นๆ ทั้งสำหรับการซื้อแบบครั้งเดียวและการสมัครใช้บริการ

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

เมื่อทำ Codelab นี้จนเสร็จสมบูรณ์ คุณจะมีทักษะในการจัดการเส้นทางการซื้อทั้งหมดและทดสอบการติดตั้งใช้งานอย่างละเอียดด้วย Play Billing Lab เพื่อให้ผู้ใช้ได้รับประสบการณ์การใช้งานที่ราบรื่นและเพิ่มโอกาสในการสร้างรายได้ใน Google Play ให้ได้สูงสุด

bug_report รายงานความผิดพลาด