Google Pay - React Native SDK

/**

Initializes the Google Pay integration from native android code.

@param activity The component activity instance from which the Google Pay integration is initialized.

@param countryCode The country code that customer use for Google Pay integration.

@param currencyCode The currency that customer use for Google Pay integration.

@param accountId The Google Pay account id that customer use for Google Pay integration.

@param requestBillingAddress boolean value that represent if billing address is required for GooglePay payment.

@param onInitSuccess an optional callback invoked when the Google Pay context is successfully initialized.

@param onInitFailure an optional callback invoked when initialization fails, providing the [Exception] that caused the failure.

*/



fun initialize(

 activity: Activity? = null,

 countryCode: String,

 currencyCode: String,

 accountId: String,

 requestBillingAddress: Boolean,

 onInitSuccess: (() -> Unit)? = null,

 onInitFailure: ((Exception) -> Unit)? = null

) 
                                

/**

Initializes the Google Pay integration from native android code.

@param fragment The fragment instance from which the Google Pay integration is initialized.

@param countryCode The country code that customer use for Google Pay integration.

@param currencyCode The currency that customer use for Google Pay integration.

@param accountId The Google Pay account id that customer use for Google Pay integration.

@param requestBillingAddress boolean value that represent if billing address is required for GooglePay payment.

@param onInitSuccess an optional callback invoked when the Google Pay context is successfully initialized.

@param onInitFailure an optional callback invoked when initialization fails, providing the [Exception] that caused the failure.

*/



fun initialize(

 fragment: Fragment? = null,

 countryCode: String,

 currencyCode: String,

 accountId: String,

 requestBillingAddress: Boolean,

 onInitSuccess: (() -> Unit)? = null,

 onInitFailure: ((Exception) -> Unit)? = null

) 
                                

/**

Initializes the Google Pay integration from native android code.

@param countryCode The country code that customer use for Google Pay integration.

@param currencyCode The currency that customer use for Google Pay integration.

@param accountId The Google Pay account id that customer use for Google Pay integration.

@param requestBillingAddress boolean value that represent if billing address is required for GooglePay payment.

 

function initializeGooglePay(

  countryCode: string,

  currencyCode: string,

  accountId: string,

  requestBillingAddress: boolean

)
                                

import android.os.Bundle

import android.util.Log

import android.view.LayoutInflater

import android.view.View

import android.view.ViewGroup

import android.widget.ProgressBar

import android.widget.Toast

import androidx.fragment.app.Fragment

import androidx.lifecycle.lifecycleScope

import com.paysafegooglepay.PaysafeGooglePayModule

import kotlinx.coroutines.Dispatchers

import kotlinx.coroutines.launch

import kotlinx.coroutines.withContext

import android.content.Context



class GooglePayFragment(

  private val countryCode: String,

  private val currencyCode: String,

  private val accountId: String,

  private val requestBillingAddress: Boolean

) : Fragment() {



  private var listener: GooglePayInitListener? = null



  override fun onAttach(context: Context) {

    super.onAttach(context)

    if (context is GooglePayInitListener) {

      listener = context

    } else {

      error ("Host must implement GooglePayInitListener")

    }

  }



  override fun onCreate(savedInstanceState: Bundle?) {

    super.onCreate(savedInstanceState)



    PaysafeGooglePayModule.initialize(

      fragment = this,

      countryCode = countryCode,

      currencyCode = currencyCode,

      accountId = accountId,

      requestBillingAddress = requestBillingAddress,

      onInitSuccess = {

        listener?.onGooglePayInitSuccess()

      },

      onInitFailure = { exception ->

        listener?.onGooglePayInitFailure(exception)

      }

    )

  }



  override fun onDetach() {

    super.onDetach()

    listener = null

  }

}




                                

import android.app.AlertDialog

import android.os.Bundle

import android.view.View

import androidx.appcompat.app.AppCompatActivity

import androidx.lifecycle.Lifecycle

import com.DemoAppExpo.databinding.ActivityGooglePayBinding

import com.paysafegooglepay.PaysafeGooglePayModule

import com.DemoAppExpo.R



class GooglePayActivity : AppCompatActivity(), GooglePayInitListener {



  private lateinit var binding: ActivityGooglePayBinding



  override fun onCreate(savedInstanceState: Bundle?) {

    super.onCreate(savedInstanceState)

    binding = ActivityGooglePayBinding.inflate(layoutInflater)

    setContentView(binding.root)



    val fragment = GooglePayFragment(

      countryCode = "US",

      currencyCode = "USD",

      accountId = "1001234110",

      requestBillingAddress = true

    )



    supportFragmentManager.beginTransaction()

      .replace(R.id.fragment_container, fragment)

      .setMaxLifecycle(fragment, Lifecycle.State.CREATED)

      .commitNow()

  }



  override fun onGooglePayInitSuccess() {

    binding.googlePayProgressBar.visibility = View.GONE

    binding.googlePayButton.visibility = View.VISIBLE

  }



  override fun onGooglePayInitFailure(exception: Exception) {

    binding.googlePayProgressBar.visibility = View.GONE

    binding.googlePayButton.visibility = View.GONE

    AlertDialog.Builder(this)

      .setTitle("Initialization Failed")

      .setMessage(exception.message ?: "Unknown error")

      .setPositiveButton("OK", null)

      .show()

  }

}
                                

/**

Tokenization using Google Pay from native android code.

@param readableGooglePayTokenizeOptions containing various parameters for tokenization of type ReadableMap

@param coroutineScope The [CoroutineScope] used to launch the tokenization request (defaults to [Dispatchers.IO]).

@param onTokenizeSuccess An optional callback invoked when tokenization is successful. Provides the resulting payment handle token as a [String].

@param onTokenizeFailure An optional callback invoked when tokenization fails. Provides the [Exception] that caused the failure.

@param onTokenizeCancelled An optional callback invoked when tokenization is cancelled by the user. Provides the [Exception] representing the cancellation reason.

*/



fun tokenize(

  readableGooglePayTokenizeOptions: ReadableMap,

  coroutineScope: CoroutineScope = CoroutineScope(Dispatchers.IO),

  onTokenizeSuccess: ((String) -> Unit)? = null,

  onTokenizeFailure: ((Exception) -> Unit)? = null,

  onTokenizeCancelled: ((Exception) -> Unit)? = null

)
                                

/**

Tokenization using Google Pay from typescript.

@param readableGooglePayTokenizeOptions containing various parameters for tokenization of type ReadableMap



function tokenizeGooglePay(readableGooglePayTokenizeOptions: unknown)
                                

object GooglePayUtils {



  fun provideGooglePayTokenizeOptions(): ReadableMap =

    Arguments.createMap().apply {

      putInt("amount", 1000)

      putString("currencyCode", "USD")

      putString("transactionType", "PAYMENT")

      putString("merchantRefNum", "12345678")

      putMap("billingDetails", createBillingDetails())

      putMap("profile", createProfile())

      putString("accountId", "123456789")

      putMap("merchantDescriptor", createMerchantDescriptor())

      putMap("shippingDetails", createShippingDetails())

      putString("simulator", "INTERNAL")

      putMap("threeDS", createThreeDS())

    }



  private fun createBillingDetails(): WritableMap =

    Arguments.createMap().apply {

      putString("nickName", "nickName")

      putString("street", "street")

      putString("city", "city")

      putString("state", "AL")

      putString("country", "US")

      putString("zip", "12345")

    }



  private fun createProfile(): WritableMap =

    Arguments.createMap().apply {

      putString("firstName", "firstName")

      putString("lastName", "lastName")

      putString("locale", "EN_GB")

      putString("merchantCustomerId", "merchantCustomerId")

      putMap("dateOfBirth", createDateOfBirth())

      putString("email", "email@mail.com")

      putString("phone", "0123456789")

      putString("mobile", "0123456789")

      putString("gender", "MALE")

      putString("nationality", "nationality")

      putArray("identityDocuments", createIdentityDocuments())

    }



  private fun createDateOfBirth(): WritableMap =

    Arguments.createMap().apply {

      putInt("day", 1)

      putInt("month", 1)

      putInt("year", 1990)

    }



  private fun createIdentityDocuments(): WritableArray {

    val idDoc = Arguments.createMap().apply {

      putString("documentNumber", "SSN123456")

    }

    return Arguments.createArray().apply {

      pushMap(idDoc)

    }

  }



  private fun createMerchantDescriptor(): WritableMap =

    Arguments.createMap().apply {

      putString("dynamicDescriptor", "dynamicDescriptor")

      putString("phone", "0123456789")

    }



  private fun createShippingDetails(): WritableMap =

    Arguments.createMap().apply {

      putString("shipMethod", "NEXT_DAY_OR_OVERNIGHT")

      putString("street", "street")

      putString("street2", "street2")

      putString("city", "Marbury")

      putString("state", "AL")

      putString("countryCode", "US")

      putString("zip", "36051")

    }



  private fun createThreeDS(): WritableMap =

    Arguments.createMap().apply {

      putString("merchantUrl", "https://api.qa.paysafe.com/checkout/v2/index.html#/desktop")

      putBoolean("process", true)

    }

}



val googlePayTokenizeOptions = GooglePayUtils.provideGooglePayTokenizeOptions()



binding.googlePayButton.setOnClickListener {

  PaysafeGooglePayModule.tokenize(googlePayTokenizeOptions)

}
                                

private fun subscribeToGooglePayEvents() {

    val reactContext = PaysafeGooglePayModule.SingletonGooglePayContext.getReactApplicationContext()

    reactContext?.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)?.let { emitter ->

        emitter.addListener(PaysafeGooglePayModule.GOOGLE_PAY_TOKENIZATION_SUCCESSFUL) { data ->

            runOnUiThread {

                binding.googlePayProgressBar.visibility = View.GONE

                // Extract token from the event payload

                val map = data as? Map<*, *>

                val token = map?.get("paymentResult") as? String ?: "No token received"

                AlertDialog.Builder(this)

                    .setTitle("Success")

                    .setMessage("Google Pay tokenization successful!\nToken:\n$token")

                    .setPositiveButton("OK", null)

                    .show()

            }

        }

    }

}
                                

const subscriptionTokenizationSuccess = eventEmitter.addListener(

  'GooglePayTokenizationSuccessful',

  (eventData) => {

    const token = eventData?.paymentHandleToken;

    router.push({

      pathname: '/paymentSuccessScreen',

      params: { token },

    });

  }

);