สร้างประสบการณ์การชำระเงินอย่างรวดเร็วบน Android ด้วย Google Pay

1. บทนำ

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

ร้านเสื้อยืดอัตโนมัติเป็นร้านค้าสุดล้ำที่ใช้ประโยชน์จากความก้าวหน้าล่าสุดของปัญญาประดิษฐ์ (AI) และใช้ข้อมูลต่างๆ เช่น ความชื่นชอบสไตล์ สภาพอากาศ ช่วงเวลาของปี และเทรนด์แฟชั่น เพื่อแนะนำสินค้าที่เหมาะที่สุดให้คุณเลือกซื้อ

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

ภาพรวม

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

แอปพลิเคชันตัวอย่าง

ใน Codelab นี้ คุณจะได้เรียนรู้วิธีการต่อไปนี้

  1. ผสานรวม Google Pay ในแอปพลิเคชัน Android ที่มีอยู่
  2. พิจารณาว่าผู้ใช้พร้อมชำระเงินโดยใช้ Google Pay หรือไม่
  3. เพิ่มปุ่ม Google Pay ลงในอินเทอร์เฟซผู้ใช้
  4. ดำเนินการชำระเงินด้วย 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

  1. เปิด Android Studio
  2. เลือกไฟล์ แล้วเลือกเปิด
  3. เลือกไดเรกทอรี kotlin ในที่เก็บ
  4. เลือกเปิด

เพิ่มไลบรารี Google Pay เป็นทรัพยากร Dependency ในไฟล์ build.gradle

  1. เปิดไฟล์บิลด์ Gradle ระดับโมดูล (kotlin/app/build.gradle.kts)
  2. เพิ่มคลัง Google Pay ลงในส่วน dependencies
implementation "com.google.android.gms:play-services-wallet:19.3.0"
  1. บันทึกไฟล์
  2. เลือกไฟล์ แล้วซิงค์โปรเจ็กต์ด้วยไฟล์ 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

คลัง 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 เรียบร้อยแล้ว

### ขั้นตอนถัดไป

### ดูข้อมูลเพิ่มเติม

คุณคิดว่าบทความนี้มีประโยชน์หรือไม่

มีประโยชน์มาก ตรงกับความคาดหวังของฉัน ไม่ค่อยมีประโยชน์