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

1. ภาพรวม

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

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

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

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

การเผยแพร่แต่ละครั้งที่ทำกับหัวข้อ Cloud Pub/Sub จะมีฟิลด์ข้อมูลเดียวที่เข้ารหัส Base64

{
 "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 หากต้องการตรวจสอบสิทธิ์ใน Security Command Center ให้ตั้งค่าข้อมูลเข้าสู่ระบบเริ่มต้นของแอปพลิเคชัน โปรดดูตั้งค่าการตรวจสอบสิทธิ์สำหรับสภาพแวดล้อมการพัฒนาในเครื่อง

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 ทราบว่าผู้ใช้ได้รับสิทธิ์ในการซื้อแล้ว คุณควรรับทราบการซื้อทันทีหลังจากให้สิทธิ์

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

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

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

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 Library

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

ทดสอบแอป

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

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

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

9. ยินดีด้วย

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

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

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

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