1. บทนำ
Google Pay API ช่วยให้ผู้ใช้ชำระเงินได้ทุกที่โดยใช้ข้อมูลการชำระเงินที่จัดเก็บไว้ในบัญชี Google ในห้องทดลองนี้ คุณใช้ไลบรารีไคลเอ็นต์ของ Google Pay สำหรับ Android เพื่อปรับปรุงประสบการณ์การชำระเงินของแอปตัวอย่างบนอุปกรณ์เคลื่อนที่แบบง่าย ด้วยการสร้างประสบการณ์ที่รวดเร็ว สะดวก และปลอดภัยยิ่งขึ้น ซึ่งนำไปสู่ Conversion ที่เพิ่มขึ้นและลูกค้าที่พึงพอใจมากขึ้น
ร้านเสื้อยืดอัตโนมัติเป็นร้านค้าสุดล้ำที่ใช้ประโยชน์จากความก้าวหน้าล่าสุดของปัญญาประดิษฐ์ (AI) และใช้ข้อมูลต่างๆ เช่น ความชื่นชอบสไตล์ สภาพอากาศ ช่วงเวลาของปี และเทรนด์แฟชั่น เพื่อแนะนำสินค้าที่เหมาะที่สุดให้คุณเลือกซื้อ
เมตริกเกี่ยวกับการมีส่วนร่วมมีอยู่มากมาย อย่างไรก็ตาม ตัวเลขเหล่านั้นยังแสดงถึงการละทิ้งจำนวนมากในระหว่างกระบวนการชำระเงินด้วย หนึ่งในเจ้าของโครงการจำได้ว่าได้เห็นวิดีโอที่ให้ผลลัพธ์ที่น่าพึงพอใจซึ่ง Google Pay ให้ไว้แก่เว็บไซต์อื่นๆ ที่คล้ายกัน เขาจึงตัดสินใจลองใช้และไว้วางใจให้คุณดูแลการผสานรวม
ภาพรวม
Codelab นี้จะแนะนำวิธีผสานรวม Google Pay เข้ากับแอปพลิเคชันที่มีอยู่ รวมถึงการระบุว่าผู้ใช้ชำระเงินโดยใช้วิธีการชำระเงินที่ Google Pay รองรับได้หรือไม่ รวมถึงตำแหน่งและการออกแบบปุ่มการชำระเงินและการดำเนินการทำธุรกรรม
ใน Codelab นี้ คุณจะได้เรียนรู้วิธีการต่อไปนี้
- ผสานรวม Google Pay ในแอปพลิเคชัน Android ที่มีอยู่
- พิจารณาว่าผู้ใช้พร้อมชำระเงินโดยใช้ Google Pay หรือไม่
- เพิ่มปุ่ม Google Pay ลงในอินเทอร์เฟซผู้ใช้
- ดำเนินการชำระเงินด้วย Google Pay ให้เสร็จสมบูรณ์
ข้อกำหนดเบื้องต้น
- Git
- Android Studio หรือสภาพแวดล้อมในการพัฒนาซอฟต์แวร์แบบทางเลือกสำหรับแอปพลิเคชัน Android
- อุปกรณ์ Android หรือโปรแกรมจำลองที่ติดตั้งบริการ Google Play เวอร์ชันล่าสุดไว้
การสนับสนุน
หากเกิดปัญหาขึ้น โปรดทราบว่าที่เก็บ GitHub แบบ google-pay/android-quickstart มีโซลูชันที่สมบูรณ์สำหรับใช้อ้างอิง
2. เริ่มต้นใช้งาน
โคลนที่เก็บจาก GitHub
ใช้คำสั่งต่อไปนี้เพื่อโคลนที่เก็บลงในโฟลเดอร์ในคอมพิวเตอร์ของคุณ
git clone https://github.com/google-pay/android-quickstart
หรือหากคุณต้องการเก็บรหัสไปรษณีย์ ให้ทำดังนี้
ดูแอปพลิเคชันตัวอย่างคร่าวๆ
คุณจะเห็นได้ว่าที่เก็บมีโครงสร้างไฟล์ที่ไม่ซับซ้อน วัตถุประสงค์หลักของ Codelab นี้คือเพื่อให้คุณสามารถปรับการผสานรวมนี้เข้ากับแอปพลิเคชันที่มีอยู่และในอนาคตของคุณ โดยไม่ขึ้นอยู่กับภาษาโปรแกรม ไลบรารี หรือเครื่องมือที่คุณเลือกทำงานด้วย
3. เปิดโปรเจ็กต์ใน Android Studio
ที่เก็บ GitHub ที่คุณโคลนมีโปรเจ็กต์ Android ที่มีกิจกรรมพื้นฐาน ในขั้นตอนนี้ คุณจะแก้ไขกิจกรรมนี้เพื่อยืนยันความพร้อมของ Google Pay และแสดงปุ่ม Google Pay
- เปิด Android Studio
- เลือกไฟล์ แล้วเลือกเปิด
- เลือกไดเรกทอรี
kotlin
ในที่เก็บ - เลือกเปิด
เพิ่มไลบรารี Google Pay เป็นทรัพยากร Dependency ในไฟล์ build.gradle
- เปิดไฟล์บิลด์ Gradle ระดับโมดูล (
kotlin/app/build.gradle.kts
) - เพิ่มคลัง Google Pay ลงในส่วน
dependencies
implementation "com.google.android.gms:play-services-wallet:19.3.0"
- บันทึกไฟล์
- เลือกไฟล์ แล้วซิงค์โปรเจ็กต์ด้วยไฟล์ Gradle
เปิดใช้ Google Pay API ในไฟล์ Android Manifest
สุดท้าย ให้เพิ่มเอลิเมนต์ meta-data
ภายในโหนด application
ของไฟล์ Manifest
<meta-data
android:name="com.google.android.gms.wallet.api.enabled"
android:value="true" />
4. ตัดสินใจว่าจะวางปุ่ม Google Pay ไว้ที่ใดในอินเทอร์เฟซ
การจัดวางและตำแหน่งโดยรวมในมุมมองของคุณเป็นส่วนสำคัญที่ส่งผลต่อแนวโน้มที่ผู้ใช้จะดำเนินการชำระเงิน ความสามารถในการเลือกรูปแบบการชำระเงินด้วยการแตะเพียงไม่กี่ครั้งโดยใช้ Google Pay ช่วยสร้างตัวเลือกใหม่ว่าจะเสนอวิธีการชำระเงินในแอปพลิเคชันแก่ผู้ใช้ที่ไหนและเมื่อใด เช่น คุณสามารถเพิ่มตัวเลือกการชำระเงินอย่างรวดเร็วได้ตั้งแต่ช่วงต้นของกระบวนการ ในพื้นที่ต่างๆ เช่น มุมมองรายละเอียดของสินค้า เพื่อให้ผู้ใช้ชำระเงินสินค้า 1 รายการที่ชอบได้อย่างรวดเร็ว
เมื่อตัดสินใจเลือกวิธีจัดเรียงอินเทอร์เฟซผู้ใช้ได้แล้ว ขั้นตอนต่อไปคือการวางปุ่ม Google Pay คุณกำหนดค่าฟีเจอร์ด้านภาพบางอย่างของปุ่มได้ เช่น ประเภท ธีม และมุมกลมมน ตัวอย่างเช่น
คลัง Google Pay จะมีมุมมองที่จะช่วยให้การเพิ่มปุ่มลงในอินเทอร์เฟซผู้ใช้ทำได้ง่ายขึ้น ต่อไปนี้คือวิธีสร้างเลย์เอาต์โดยใช้ XML
<com.google.android.gms.wallet.button.PayButton
android:id="@+id/googlePayButton"
android:layout_width="match_parent"
android:layout_height="wrap_content" />
หลังจากนั้นคุณจะเริ่มต้นปุ่มนี้แบบเป็นโปรแกรม (ดูตัวอย่าง)
หากคุณใช้ Jetpack Compose ให้เพิ่มทรัพยากร Dependency ต่อไปนี้เวอร์ชันล่าสุดในไฟล์ build.gradle
หรือ build.gradle.kts
implementation "com.google.pay.button:compose-pay-button:1.0.0"
และเพิ่มปุ่ม Google Pay ลงในเลย์เอาต์ "เขียน" ดังนี้
PayButton(
modifier = Modifier
.testTag("payButton")
.fillMaxWidth(),
onClick = onGooglePayButtonClick,
allowedPaymentMethods = PaymentsUtil.allowedPaymentMethods.toString()
)
ลองดูตัวอย่างใน GitHub เพื่อดูข้อมูลเพิ่มเติมเกี่ยวกับวิธีสร้างรายการวิธีการชำระเงินที่ยอมรับ
5. เริ่มต้นและกำหนดค่า Google Pay API
สร้างอินสแตนซ์ไคลเอ็นต์ API
หากต้องการเริ่มใช้ API คุณจะต้องสร้างอินสแตนซ์ออบเจ็กต์ไคลเอ็นต์ที่ใช้เรียก Google Pay API ซึ่งคุณจะทำได้ทันทีที่สร้างกิจกรรมหรือตัวควบคุมโดยทำดังนี้
private val paymentsClient: PaymentsClient = createPaymentsClient(context)
fun createPaymentsClient(context: Context): PaymentsClient {
val walletOptions = Wallet.WalletOptions.Builder()
.setEnvironment(WalletConstants.ENVIRONMENT_TEST).build()
return Wallet.getPaymentsClient(context, walletOptions)
}
ไคลเอ็นต์การชำระเงินเริ่มต้นด้วยออบเจ็กต์ WalletOptions การตั้งค่าสภาพแวดล้อมเป็น ENVIRONMENT_TEST ทำให้คุณสามารถทดสอบข้อมูลการชำระเงินได้ เมื่อพร้อมออกธุรกรรมการชำระเงินจริงแล้ว คุณจะอัปเดตพร็อพเพอร์ตี้ของสภาพแวดล้อมเป็น ENVIRONMENT_PRODUCTION ได้
โครงสร้างของคำขอ Google Pay
เมื่อส่งคำขอไปยัง Google Pay API คุณจะต้องใส่พารามิเตอร์การกำหนดค่าจำนวนหนึ่งในคำขอ เช่น เวอร์ชันของ API ที่กำหนดเป้าหมาย ออบเจ็กต์นี้มีข้อมูลเกี่ยวกับวิธีการชำระเงินที่ยอมรับในแอปพลิเคชันของคุณเพื่อจุดประสงค์ของ Codelab นี้ โครงสร้างสุดท้ายจะมีลักษณะดังนี้
{
apiVersion: number,
apiVersionMinor: number,
allowedPaymentMethods: Array
}
พร็อพเพอร์ตี้ allowedPaymentMethods
จะใช้รายการวิธีการชำระเงิน คุณต้องระบุพร็อพเพอร์ตี้ต่อไปนี้สำหรับวิธีการชำระเงินทุกวิธี
{
type: 'CARD',
parameters: {
allowedCardNetworks: Array.<string>,
allowedAuthMethods: Array.<string>
}
}
การกำหนดค่าวิธีการชำระเงิน
สำหรับตัวอย่างนี้ คุณจะรับการชำระเงินผ่านบัตรสำหรับ Mastercard และ Visa เท่านั้น ทั้งในแบบฟอร์มโทเค็นและหมายเลขบัญชีหลัก (PAN) วิธีการชำระเงินของคุณมีลักษณะดังนี้
private val baseCardPaymentMethod =
JSONObject()
.put("type", "CARD")
.put("parameters", JSONObject()
.put("allowedCardNetworks", JSONArray(listOf("VISA", "MASTERCARD")))
.put("allowedAuthMethods", JSONArray(listOf("PAN_ONLY", "CRYPTOGRAM_3DS")))
)
สรุปข้อมูลทั้งหมด
มาสรุปข้อมูลกัน คุณได้กำหนดวิธีการชำระเงิน 1 วิธีที่จะยอมรับในแอปพลิเคชันของคุณ และคุณกำลังจะใช้ API เวอร์ชัน 2.0 การกำหนดค่าที่ได้จะมีลักษณะดังนี้
private val baseCardPaymentMethod = JSONObject()
.put("type", "CARD")
.put("parameters", JSONObject()
.put("allowedCardNetworks", JSONArray(listOf("VISA", "MASTERCARD")))
.put("allowedAuthMethods", JSONArray(listOf("PAN_ONLY", "CRYPTOGRAM_3DS")))
)
private val googlePayBaseConfiguration = JSONObject()
.put("apiVersion", 2)
.put("apiVersionMinor", 0)
.put("allowedPaymentMethods", JSONArray(listOf(baseCardPaymentMethod)))
}
6. พิจารณาความพร้อมในการชำระเงินด้วย Google Pay
การใช้คำขอisReadyToPay
ช่วยให้คุณระบุได้ว่าผู้ใช้ในแอปพลิเคชันชำระเงินด้วย Google Pay ได้หรือไม่ ใช้ข้อมูลนี้เพื่อปรับประสบการณ์ของผู้ใช้ในแอปพลิเคชันของคุณให้สอดคล้องกัน
โดยคำขอกำหนดให้คุณต้องระบุเวอร์ชันของ Google Pay API และรายการวิธีการชำระเงินที่อนุญาตในแอปพลิเคชัน ออบเจ็กต์การกำหนดค่าพื้นฐานที่กำหนดไว้ในขั้นตอนก่อนหน้ามีข้อมูลต่อไปนี้
private suspend fun fetchCanUseGooglePay(): Boolean {
val request = IsReadyToPayRequest.fromJson(googlePayBaseConfiguration.toString())
return paymentsClient.isReadyToPay(request).await()
}
ส่วน Google Pay API นั้นใช้ Task
เพื่อแก้ปัญหาการโทรระยะไกล Tasks API ช่วยให้คุณแก้ไขการดำเนินการของ Task
ได้โดยใช้ Coroutine ดูข้อมูลเพิ่มเติม
คุณจะเห็นได้ว่าการตรวจสอบความพร้อมในการชำระเงินด้วย Google Pay แสดงผลเป็นออบเจ็กต์บูลีน หากผลลัพธ์เป็นที่น่าพอใจ ขั้นตอนต่อไปคือการแสดงปุ่ม Google Pay ในอินเทอร์เฟซผู้ใช้ หรือลองแสดง UI เพิ่มเติมที่รองรับวิธีการชำระเงินอื่นๆ
แสดงปุ่ม Google Pay
จากนั้นกลับไปที่อินเทอร์เฟซผู้ใช้แล้วอัปเดตตำแหน่งปุ่ม Google Pay ตามผลการโทรครั้งก่อน ตัวอย่างนี้ใช้คลาสในการเก็บสถานะของมุมมองซึ่งจะอัปเดตตามข้อมูลที่ป้อน เช่น การเรียก isReadyToPay
if (payUiState !is PaymentUiState.NotStarted) {
PayButton(
modifier = Modifier
.testTag("payButton")
.fillMaxWidth(),
onClick = onGooglePayButtonClick,
allowedPaymentMethods = PaymentsUtil.allowedPaymentMethods.toString()
)
}
7. ได้เวลาจ่ายเงิน!
### เตรียมคำขอการชำระเงิน
เมื่อถึงจุดนี้ คุณได้โหลด Google Pay API และพิจารณาแล้วว่าผู้ใช้ในแอปพลิเคชันของคุณใช้ Google Pay เพื่อชำระเงินได้ คุณจึงแสดงปุ่มการชำระเงิน Google Pay ใน UI และตอนนี้ผู้ใช้ก็พร้อมเริ่มธุรกรรมแล้ว ตอนนี้ถึงเวลาโหลดชีตการชำระเงินซึ่งมีรูปแบบการชำระเงินที่ผู้ใช้ของคุณได้ใช้งานได้
คำขอนี้จะต้องการพร็อพเพอร์ตี้ในออบเจ็กต์การกำหนดค่าพื้นฐานที่กำหนดไว้ก่อนหน้านี้ (apiVersion
, apiVersionMinor
และ allowedPaymentMethods
) ซึ่งคล้ายกับการเรียก isReadyToPay
ในครั้งนี้ คุณจะต้องใช้พร็อพเพอร์ตี้ใหม่ที่ชื่อ tokenizationSpecification
และพารามิเตอร์เพิ่มเติมเพื่ออธิบายธุรกรรมและขอข้อมูล เช่น ที่อยู่สำหรับการเรียกเก็บเงินและที่อยู่สำหรับจัดส่ง หรือข้อมูลของผู้ใช้ อีเมลหรือหมายเลขโทรศัพท์
#### พร็อพเพอร์ตี้ tokenizationSpecification
ข้อกำหนดด้านการแปลงข้อมูลเป็นโทเค็นจะกำหนดวิธีจัดการและใช้วิธีการชำระเงินที่ผู้ใช้เลือกในการทำธุรกรรม
กลไกการจัดการที่รองรับมี 2 ประเภท หากคุณกำลังประมวลผลธุรกรรมการชำระเงินจากภายในเซิร์ฟเวอร์ที่เป็นไปตาม PCI DSS ให้ใช้ประเภทข้อกำหนด DIRECT
ในตัวอย่างนี้ คุณใช้เกตเวย์การชำระเงินในการประมวลผลการชำระเงิน คุณจึงต้องกำหนดประเภทข้อกำหนดเป็น PAYMENT_GATEWAY
ดังนี้
private val tokenizationSpecification = JSONObject()
.put("type", "PAYMENT_GATEWAY")
.put("parameters", JSONObject(mapOf(
"gateway" to "example",
"gatewayMerchantId" to "exampleGatewayMerchantId")))
}
ในหัวข้อ parameters
คุณจะระบุเกตเวย์ได้จากรายชื่อผู้ให้บริการที่ Google Pay API รองรับ รวมถึงการกำหนดค่าเพิ่มเติมที่เกตเวย์แต่ละรายการต้องการ สำหรับวัตถุประสงค์ของ Lab นี้ คุณจะใช้เกตเวย์ example
ซึ่งจะส่งคืนผลการทดสอบสำหรับธุรกรรมที่ดำเนินการ
พารามิเตอร์เพิ่มเติม
ในทำนองเดียวกัน คุณขอรายละเอียดเพิ่มเติมจากผู้ใช้เพื่อให้ทำการสั่งซื้อได้สำเร็จ ในตัวอย่างนี้คุณเพิ่มพร็อพเพอร์ตี้ billingAddressRequired
และ billingAddressParameters
เพื่อระบุว่าสำหรับธุรกรรมนี้ คุณต้องระบุที่อยู่สำหรับการเรียกเก็บเงินของผู้ใช้แบบเต็มพร้อมทั้งหมายเลขโทรศัพท์
private val cardPaymentMethod = JSONObject()
.put("type", "CARD")
.put("tokenizationSpecification", tokenizationSpecification)
.put("parameters", JSONObject()
.put("allowedCardNetworks", JSONArray(listOf("VISA", "MASTERCARD")))
.put("allowedAuthMethods", JSONArray(listOf("PAN_ONLY", "CRYPTOGRAM_3DS")))
.put("billingAddressRequired", true)
.put("billingAddressParameters", JSONObject(mapOf("format" to "FULL")))
)
#### ใส่ข้อมูลเพิ่มเติมเกี่ยวกับธุรกรรม
พร็อพเพอร์ตี้ transactionInfo
มีออบเจ็กต์ที่มีรายละเอียดทางการเงินเกี่ยวกับธุรกรรม ได้แก่ price และรหัสสกุลเงิน (รูปแบบอัลฟ่า ISO 4217) รวมถึงสถานะของราคา ซึ่งอาจเป็นสุดท้ายหรือโดยประมาณ ขึ้นอยู่กับลักษณะของธุรกรรม (เช่น ราคาอาจแตกต่างกันไปตามที่อยู่สำหรับจัดส่งที่ระบุไว้) ดังนี้
private val transactionInfo = JSONObject()
.put("totalPrice", "123.45")
.put("totalPriceStatus", "FINAL")
.put("currencyCode", "USD")
}
#### การเพิ่มข้อมูลทางธุรกิจ
คำขอการชำระเงินจะใช้ข้อมูลเกี่ยวกับผู้ขายที่ดำเนินการตามคำขอภายใต้พร็อพเพอร์ตี้ merchantInfo
ใน Codelab นี้จะมุ่งเน้นที่พร็อพเพอร์ตี้ 2 รายการ ได้แก่
merchantId
เก็บตัวระบุที่เชื่อมโยงกับบัญชีของคุณ คุณสามารถรับรหัสระบุผู้ขายได้ในชำระเงินและ Wallet Console โปรดทราบว่าระบบไม่ได้ประเมินช่องนี้เมื่อใช้สภาพแวดล้อมTEST
merchantName
คือชื่อแอปพลิเคชันหรือองค์กรของคุณที่ผู้ใช้มองเห็นได้ ซึ่งอาจแสดงไว้ในชีตการชําระเงิน Google Pay เพื่อให้บริบทเพิ่มเติมเกี่ยวกับผู้ที่ส่งคําขอดําเนินการ
เมื่อพร้อมแล้ว ให้เพิ่มข้อมูลเกี่ยวกับผู้ขายลงในออบเจ็กต์ paymentDataRequest
ดังนี้
private val merchantInfo = JSONObject()
.put("merchantName", "Example Merchant")
.put("merchantId", "01234567890123456789")
ส่งคำขอและประมวลผลผลลัพธ์
แล้วนำออบเจ็กต์การกำหนดค่ามารวมกันและส่งไปยังคำขอ loadPaymentData
private val paymentDataRequestJson = JSONObject(googlePayBaseConfiguration.toString())
.put("allowedPaymentMethods", JSONArray().put(cardPaymentMethod))
.put("transactionInfo", transactionInfo)
.put("merchantInfo", merchantInfo)
ณ จุดนี้ คุณมีข้อมูลทุกอย่างที่ต้องใช้ในการขอรูปแบบการชำระเงินที่ถูกต้องจาก Google Pay API ซึ่งทำได้โดยใช้เมธอด loadPaymentData
ในออบเจ็กต์ PaymentsClient
โดยการส่งผ่านในการกำหนดค่าที่คุณเพิ่งกำหนด
fun getLoadPaymentDataTask(): Task<PaymentData> {
val request = PaymentDataRequest.fromJson(paymentDataRequestJson.toString())
return paymentsClient.loadPaymentData(request)
}
private fun requestPayment() {
val task = getLoadPaymentDataTask()
task.addOnCompleteListener(paymentDataLauncher::launch)
}
Google Pay API ใช้ Activity Result API เพื่อแสดงผลการค้นหา API มีสัญญาที่ช่วยให้ประมวลผลและตอบสนองต่อผลลัพธ์ได้ง่ายขึ้น ตัวอย่างนี้ใช้สัญญา GetPaymentDataResult
ซึ่งมีข้อมูลเกี่ยวกับการดำเนินการนอกเหนือจากผลลัพธ์การชำระเงิน
private val paymentDataLauncher = registerForActivityResult(GetPaymentDataResult()) { taskResult ->
when (taskResult.status.statusCode) {
CommonStatusCodes.SUCCESS -> {
taskResult.result!!.let {
Log.i("Google Pay result:", it.toJson())
// TODO something with the result
}
}
CommonStatusCodes.CANCELED -> // The user canceled
AutoResolveHelper.RESULT_ERROR -> // The API returned an error (it.status: Status)
CommonStatusCodes.INTERNAL_ERROR -> // Handle other unexpected errors
}
}
การเรียกวิธีการนี้จะเรียกใช้การนำเสนอชีตการชำระเงิน Google Pay หากไม่มีข้อผิดพลาดในการกำหนดค่า คุณจะเห็นรายการวิธีการชำระเงินที่ถูกต้องซึ่งเชื่อมโยงกับบัญชีที่เข้าสู่ระบบในปัจจุบัน
เมื่อเลือกแล้ว ชีตจะปิดและส่งผลกลับไปยังกิจกรรมของคุณ และตัวเปิดผลลัพธ์กิจกรรมที่ระบุไว้ด้านบนจะบันทึกเอาไว้
หากเลือกไว้สำเร็จ ผลลัพธ์จะแสดงพร้อมกับออบเจ็กต์ PaymentData
ที่มีข้อมูลที่เกี่ยวข้องกับวิธีการชำระเงินที่เลือกไว้
{
"apiVersionMinor": 0,
"apiVersion": 2,
"paymentMethodData": {
"description": "Visa •••• 1234",
"tokenizationData": {
"type": "PAYMENT_GATEWAY",
"token": "examplePaymentMethodToken"
},
"type": "CARD",
"info": {
"cardNetwork": "VISA",
"cardDetails": "1234",
"billingAddress": {
"phoneNumber": ...,
...
}
}
}
}
ตอนนี้คุณสามารถใช้วิธีการชำระเงินนี้เพื่อทำธุรกรรมด้วยเกตเวย์การชำระเงินของคุณให้เสร็จสมบูรณ์ได้
private fun handlePaymentSuccess(paymentData: PaymentData) {
val paymentMethodToken = paymentData
.getJSONObject("tokenizationData")
.getString("token")
// Sample TODO: Use this token to perform a payment through your payment gateway
}
8. ยินดีด้วย
คุณเพิ่ม Google Pay ลงในแอปพลิเคชัน Android เรียบร้อยแล้ว
### ขั้นตอนถัดไป
- ทดสอบ Google Pay ในแอปพลิเคชัน
- ดูรหัสระบุผู้ขายได้ในส่วนชำระเงินและ คอนโซล Wallet
- ตรวจสอบรายการตรวจสอบการผสานรวม
### ดูข้อมูลเพิ่มเติม
- ดูเอกสารอ้างอิง API
- แก้ปัญหาการผสานรวมหากพบข้อผิดพลาด
- ดูบทแนะนำการผสานรวมในเอกสารสำหรับคำแนะนำในการผสานรวมโดยใช้ภาษาโปรแกรมและไลบรารีอื่นๆ
- โปรดดูตัวอย่างแอปพลิเคชันใน GitHub เพื่อดูการสาธิตการทำงานที่สมบูรณ์