Google Pay की मदद से Android पर तेज़ी से चेकआउट करने का अनुभव पाएं

1. परिचय

Google Pay API, लोगों को उनके Google खाते में सेव की गई क्रेडिट/डेबिट कार्ड की जानकारी का इस्तेमाल करके, कहीं भी पेमेंट करने का विकल्प देता है. इस लैब में, आप Android के लिए Google Pay की क्लाइंट लाइब्रेरी का इस्तेमाल करते हैं, ताकि आप आसान सैंपल मोबाइल ऐप्लिकेशन के चेकआउट अनुभव को बेहतर बना सकें. इससे आपको ज़्यादा तेज़, ज़्यादा सुविधाजनक, और सुरक्षित अनुभव मिलता है. इससे ज़्यादा कन्वर्ज़न मिलते हैं और ग्राहक खुश रहते हैं.

Auto टी-शर्ट की दुकान, एक इनोवेटिव स्टोर है. यहां पर आर्टिफ़िशियल इंटेलिजेंस की नई सुविधाओं का इस्तेमाल किया जाता है. साथ ही, अपनी स्टाइल, मौसम, साल का समय, और फ़ैशन ट्रेंड जैसी जानकारी का इस्तेमाल करके, आपको किसी आइटम को खरीदने का सुझाव दिया जाता है.

दर्शकों की दिलचस्पी से जुड़े आंकड़े अब आपको नहीं दिखेंगे. माफ़ करें, चेकआउट की प्रोसेस के दौरान, साइट छोड़कर जाने वाले लोगों की संख्या में भी काफ़ी बढ़ोतरी दिख रही है. समस्या को हल करने के लिए, प्रोजेक्ट के मालिकों में से एक ने एक वीडियो देखा था, जिसमें Google Pay ने भी इसी तरह की दूसरी साइटों के लिए भरोसेमंद नतीजे दिखाए थे. इसलिए, प्रोजेक्ट के मालिकों में से एक यह फ़ैसला करता है कि आप इंटिग्रेशन के लिए आप पर भरोसा करेंगे.

खास जानकारी

इस कोडलैब से आपको Google Pay को किसी मौजूदा ऐप्लिकेशन के साथ इंटिग्रेट करने के बारे में जानकारी मिलती है. इसमें यह पता करना भी शामिल है कि उपयोगकर्ता, Google Pay के साथ काम करने वाले पेमेंट के तरीके का इस्तेमाल करके पेमेंट कर सकता है या नहीं. साथ ही, पेमेंट बटन का प्लेसमेंट और डिज़ाइन, और लेन-देन पूरा करना भी शामिल है.

सैंपल ऐप्लिकेशन

इस कोडलैब में, आपको ये काम करने के बारे में जानकारी मिलेगी:

  1. Google Pay को मौजूदा Android ऐप्लिकेशन में इंटिग्रेट करें
  2. यह पता करना कि उपयोगकर्ता Google Pay का इस्तेमाल करके पेमेंट करने के लिए तैयार है या नहीं
  3. अपने यूज़र इंटरफ़ेस में Google Pay बटन जोड़ें
  4. Google Pay से पेमेंट करें

ज़रूरी शर्तें

  • Git
  • Android Studio या Android ऐप्लिकेशन के लिए दूसरा डेवलपमेंट एनवायरमेंट
  • ऐसा Android डिवाइस या एम्युलेटर जिस पर Google Play services का सबसे नया वर्शन इंस्टॉल हो

सहायता

अगर आपको कोई समस्या आ रही है, तो GitHub रिपॉज़िटरी में google-pay/android-quickstart रिपॉज़िटरी में रेफ़रंस के लिए पूरा समाधान मौजूद है.

2. अपनी प्रोफ़ाइल बनाना शुरू करें

GitHub से रिपॉज़िटरी का क्लोन बनाएं

अपने कंप्यूटर पर, डेटा स्टोर करने की जगह का क्लोन बनाने के लिए, नीचे दिए गए निर्देश का इस्तेमाल करें:

git clone https://github.com/google-pay/android-quickstart

या अगर आप ZIP संग्रह का इस्तेमाल करना चाहते हैं, तो:

सैंपल ऐप्लिकेशन को स्कैन करें

जैसा कि आपको दिख रहा है, रिपॉज़िटरी में एक मुश्किल फ़ाइल स्ट्रक्चर की सुविधा है. इस कोडलैब का मुख्य मकसद आपको मौजूदा और आने वाले समय में होने वाले ऐप्लिकेशन के हिसाब से इस इंटिग्रेशन को अपनाने की सुविधा देना है. आपको इस बात से कोई फ़र्क़ नहीं पड़ता कि आपने प्रोग्रामिंग भाषा, लाइब्रेरी या टूल का इस्तेमाल करने के लिए क्या चुना है.

3. प्रोजेक्ट को Android Studio में खोलें

आपने GitHub डेटा स्टोर करने की जिस जगह की जानकारी क्लोन की है उसमें बुनियादी गतिविधि वाला एक Android प्रोजेक्ट शामिल है. इस चरण में, आपको इस गतिविधि में बदलाव करके, यह पुष्टि करनी होगी कि Google Pay आपके लिए तैयार है या नहीं. साथ ही, आपको Google Pay बटन दिखाना होगा.

  1. Android Studio खोलना
  2. पहले फ़ाइल, फिर खोलें को चुनें
  3. रिपॉज़िटरी में kotlin डायरेक्ट्री चुनें
  4. खोलें को चुनें

अपनी build.gradle फ़ाइल में, Google Pay की लाइब्रेरी को डिपेंडेंसी के तौर पर जोड़ें

  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 फ़ाइलों के साथ प्रोजेक्ट सिंक करें चुनें

अपनी Android मेनिफ़ेस्ट फ़ाइल में Google Pay API चालू करना

आखिर में, अपनी मेनिफ़ेस्ट फ़ाइल के application नोड में meta-data एलिमेंट जोड़ें:

<meta-data
    android:name="com.google.android.gms.wallet.api.enabled"
    android:value="true" />

4. अपने इंटरफ़ेस में Google Pay बटन की जगह तय करना

आपके व्यू में लेआउट और पूरा प्लेसमेंट, ऐसे अहम पहलू हैं जिनसे इस बात पर असर पड़ता है कि आपके उपयोगकर्ताओं के पेमेंट लेन-देन पूरा करने की कितनी संभावना है. Google Pay का इस्तेमाल करके कुछ ही टैप में पेमेंट का तरीका चुना जा सकता है. इससे यह पता चलता है कि उपयोगकर्ताओं को आपके ऐप्लिकेशन में पेमेंट का तरीका कब और कहां उपलब्ध कराना है. उदाहरण के लिए, प्रोसेस की शुरुआत में आइटम की ज़्यादा जानकारी वाले व्यू जैसी जगहों में झटपट चेकआउट के विकल्प जोड़े जा सकते हैं. इससे उपयोगकर्ता अपनी पसंद के एक आइटम के लिए तुरंत पेमेंट कर पाएंगे.

अपना यूज़र इंटरफ़ेस व्यवस्थित करने का तरीका तय करने के बाद, Google Pay बटन डालें. बटन की कुछ विज़ुअल सुविधाएं कॉन्फ़िगर की जा सकती हैं. जैसे, टाइप, थीम, और कोने की गोलाई. यहां कुछ उदाहरण दिए गए हैं:

Google Pay के डाइनैमिक बटन का उदाहरण

Google Pay की लाइब्रेरी में एक व्यू होता है. इससे यूज़र इंटरफ़ेस में बटन जोड़ने की प्रोसेस को आसान बनाया जा सकता है. अगर एक्सएमएल का इस्तेमाल करके लेआउट बनाए जा रहे हैं, तो यहां बताया गया है कि ऐसा कैसे किया जा सकता है:

<com.google.android.gms.wallet.button.PayButton
    android:id="@+id/googlePayButton"
    android:layout_width="match_parent"
    android:layout_height="wrap_content" />

बाद में, बटन को प्रोग्राम के हिसाब से शुरू किया जा सकता है (उदाहरण देखें).
अगर Jetpack Compose का इस्तेमाल किया जा रहा है, तो अपनी 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 को शुरू और कॉन्फ़िगर करें

एपीआई क्लाइंट को इंस्टैंशिएट करें

एपीआई का इस्तेमाल शुरू करने के लिए, आपको एक क्लाइंट ऑब्जेक्ट इंस्टैंशिएट करना होगा. इसका इस्तेमाल 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 के लिए अनुरोध जारी करने पर, आपको अपने अनुरोधों में कई कॉन्फ़िगरेशन पैरामीटर शामिल करने होंगे. जैसे, टारगेट किए जा रहे एपीआई का वर्शन. इस कोडलैब के लिए, इस ऑब्जेक्ट में आपके आवेदन में स्वीकार किए गए, पैसे चुकाने के तरीकों के बारे में जानकारी भी शामिल है. फ़ाइनल स्ट्रक्चर इस तरह दिखता है:

{
    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")))
        )

यह रही पूरी जानकारी

चलिए, फिर से देखते हैं. आपने अपने ऐप्लिकेशन में पेमेंट का एक तरीका स्वीकार किया है और एपीआई के वर्शन 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 कार्रवाइयों को रिज़ॉल्व किया जा सकता है. ज़्यादा जानें

जैसा कि आपको दिख रहा है, Google Pay के ज़रिए पेमेंट करने के लिए तैयार है या नहीं, इसकी जांच करने पर आपको बूलियन ऑब्जेक्ट दिखता है. अगर नतीजा पॉज़िटिव होता है, तो अगला चरण अपने यूज़र इंटरफ़ेस में Google Pay बटन दिखाना है. अगर ऐसा नहीं है, तो पेमेंट के अन्य तरीकों के साथ काम करने वाला कोई अन्य यूज़र इंटरफ़ेस (यूआई) दिखाएं.

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 का पेमेंट बटन दिखाया है और अब आपका उपयोगकर्ता लेन-देन शुरू करने के लिए तैयार है. अब पेमेंट शीट में, आपके उपयोगकर्ता के लिए उपलब्ध पेमेंट के तरीके लोड किए जा सकते हैं.

isReadyToPay को किए जाने वाले कॉल की तरह ही, इस अनुरोध के लिए, बेस कॉन्फ़िगरेशन ऑब्जेक्ट में मौजूद उन प्रॉपर्टी की ज़रूरत होती है जो पहले तय की गई थीं (apiVersion, apiVersionMinor, और allowedPaymentMethods). इस बार, आपको tokenizationSpecification नाम की एक नई प्रॉपर्टी और लेन-देन की जानकारी देने के लिए अतिरिक्त पैरामीटर की भी ज़रूरत होगी. साथ ही, बिलिंग और शिपिंग पते या उपयोगकर्ताओं की जानकारी जैसी जानकारी का अनुरोध करना होगा ईमेल पता या फ़ोन नंबर डालें.

#### tokenizationSpecification प्रॉपर्टी

टोकनाइज़ेशन के स्पेसिफ़िकेशन से यह तय होता है कि आपके उपयोगकर्ताओं ने पेमेंट के जिस तरीके को चुना है उसे कैसे मैनेज और इस्तेमाल किया जाएगा.

हैंडलिंग के दो अलग-अलग तरीके उपलब्ध हैं. अगर पेमेंट का लेन-देन, पीसीआई डीएसएस का पालन करने वाले सर्वर से किया जा रहा है, तो 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 के साथ काम करने वाली कंपनियों की सूची में जाकर गेटवे तय किया जा सकता है. साथ ही, हर गेटवे के लिए ज़रूरी अतिरिक्त कॉन्फ़िगरेशन भी दिया जा सकता है. इस लैब के लिए, आपको 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 प्रॉपर्टी में, लेन-देन से जुड़ी वित्तीय जानकारी वाला एक ऑब्जेक्ट होता है. जैसे, कीमत और मुद्रा कोड (ISO 4217 ऐल्फ़ा फ़ॉर्मैट). साथ ही, कीमत की स्थिति भी होती है. यह लेन-देन किस तरह की है, इसके आधार पर फ़ाइनल या अनुमानित हो सकता है (उदाहरण के लिए: बताए गए शिपिंग पते के आधार पर कीमत अलग-अलग हो सकती है):

private val transactionInfo = JSONObject()
    .put("totalPrice", "123.45")
    .put("totalPriceStatus", "FINAL")
    .put("currencyCode", "USD")
}

#### अपने कारोबार की जानकारी जोड़ना

पेमेंट के अनुरोध में, merchantInfo प्रॉपर्टी के तहत अनुरोध करने वाले व्यापारी या कंपनी की जानकारी मिलती है. इस कोडलैब में, दो प्रॉपर्टी पर फ़ोकस किया जाएगा:

  • merchantId, आपके खाते से जुड़े आइडेंटिफ़ायर को होल्ड करता है. अपना कारोबारी आईडी, Pay & 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 से अनुरोध करने से जुड़ी हर जानकारी होगी. ऐसा करने के लिए, PaymentsClient ऑब्जेक्ट में loadPaymentData तरीके का इस्तेमाल करें. साथ ही, आपने अभी जिस कॉन्फ़िगरेशन को सेट किया है उसे पास करें:

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 नतीजे 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 ऐप्लिकेशन में जोड़ लिया है.

### अगले चरण

### ज़्यादा जानें

क्या आपको यह सुविधा काम की लगी?

बहुत काम की है मेरी उम्मीद के करीब-करीब बिलकुल नहीं