@gmisoftware/react-native-pay 0.0.4

package/android/gradle.properties

@@ -0,0 +1,8 @@
+NitroPay_kotlinVersion=2.1.20
+NitroPay_minSdkVersion=23
+NitroPay_targetSdkVersion=36
+NitroPay_compileSdkVersion=36
+NitroPay_ndkVersion=27.1.12297006
+
+# Google Pay Environment: TEST or PRODUCTION
+GOOGLE_PAY_ENVIRONMENT=TEST

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,2 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+</manifest>

package/android/src/main/cpp/cpp-adapter.cpp

@@ -0,0 +1,6 @@
+#include <jni.h>
+#include "NitroPayOnLoad.hpp"
+
+JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void*) {
+  return margelo::nitro::pay::initialize(vm);
+}

package/android/src/main/java/com/margelo/nitro/pay/Constants.kt

@@ -0,0 +1,49 @@
+package com.margelo.nitro.pay
+
+/**
+ * Constants used across the payment module
+ */
+object PaymentConstants {
+    // Activity result codes
+    const val LOAD_PAYMENT_DATA_REQUEST_CODE = 991
+    
+    // Google Pay API versions
+    const val API_VERSION = 2
+    const val API_VERSION_MINOR = 0
+    
+    // Payment method types
+    const val PAYMENT_METHOD_CARD = "CARD"
+    
+    // Auth methods
+    const val AUTH_PAN_ONLY = "PAN_ONLY"
+    const val AUTH_CRYPTOGRAM_3DS = "CRYPTOGRAM_3DS"
+    
+    // Card networks
+    const val NETWORK_VISA = "VISA"
+    const val NETWORK_MASTERCARD = "MASTERCARD"
+    const val NETWORK_AMEX = "AMEX"
+    const val NETWORK_DISCOVER = "DISCOVER"
+    
+    // Tokenization
+    const val TOKENIZATION_PAYMENT_GATEWAY = "PAYMENT_GATEWAY"
+    const val DEFAULT_GATEWAY = "example"
+    const val DEFAULT_GATEWAY_MERCHANT_ID = "exampleGatewayMerchantId"
+    
+    // Transaction
+    const val TOTAL_PRICE_STATUS_FINAL = "FINAL"
+    const val TOTAL_PRICE_LABEL_DEFAULT = "Total"
+    const val LINE_ITEM_TYPE = "LINE_ITEM"
+    const val PENDING_TYPE = "PENDING"
+    
+    // Merchant
+    const val DEFAULT_MERCHANT_NAME = "Example Merchant"
+    
+    // Supported networks (lowercase for comparison)
+    val SUPPORTED_NETWORKS = listOf("visa", "mastercard", "amex", "discover")
+    
+    // Logging tags
+    const val TAG_PAYMENT_HANDLER = "HybridPaymentHandler"
+    const val TAG_GOOGLE_PAY_BUTTON = "HybridGooglePayButton"
+}
+
+

package/android/src/main/java/com/margelo/nitro/pay/GooglePayButtonFactory.kt

@@ -0,0 +1,95 @@
+package com.margelo.nitro.pay
+
+import android.content.Context
+import android.util.Log
+import com.google.android.gms.wallet.button.ButtonConstants
+import com.google.android.gms.wallet.button.ButtonOptions
+import com.google.android.gms.wallet.button.PayButton
+
+/**
+ * Factory for creating and configuring Google Pay buttons
+ */
+object GooglePayButtonFactory {
+    
+    /**
+     * Creates a configured PayButton
+     */
+    fun createButton(
+        context: Context,
+        buttonType: GooglePayButtonType,
+        theme: GooglePayButtonTheme,
+        radius: Double?,
+        onPress: (() -> Unit)?
+    ): PayButton {
+        val allowedPaymentMethods = GooglePayRequestBuilder.createAllowedCardNetworks()
+        
+        val buttonOptions = ButtonOptions.newBuilder()
+            .setButtonType(mapButtonType(buttonType))
+            .setButtonTheme(mapTheme(theme))
+            .setAllowedPaymentMethods(createAllowedPaymentMethodsJson(allowedPaymentMethods))
+            .apply {
+                radius?.let { r ->
+                    if (r >= 0) {
+                        setCornerRadius(r.toInt())
+                    }
+                }
+            }
+            .build()
+        
+        val button = PayButton(context)
+        button.initialize(buttonOptions)
+        button.setOnClickListener {
+            onPress?.invoke()
+        }
+        
+        return button
+    }
+    
+    /**
+     * Maps GooglePayButtonType to ButtonConstants
+     */
+    private fun mapButtonType(type: GooglePayButtonType): Int {
+        return when (type) {
+            GooglePayButtonType.BUY -> ButtonConstants.ButtonType.BUY
+            GooglePayButtonType.BOOK -> ButtonConstants.ButtonType.BOOK
+            GooglePayButtonType.CHECKOUT -> ButtonConstants.ButtonType.CHECKOUT
+            GooglePayButtonType.DONATE -> ButtonConstants.ButtonType.DONATE
+            GooglePayButtonType.ORDER -> ButtonConstants.ButtonType.ORDER
+            GooglePayButtonType.PAY -> ButtonConstants.ButtonType.PAY
+            GooglePayButtonType.SUBSCRIBE -> ButtonConstants.ButtonType.SUBSCRIBE
+            GooglePayButtonType.PLAIN -> ButtonConstants.ButtonType.PLAIN
+        }
+    }
+    
+    /**
+     * Maps GooglePayButtonTheme to ButtonConstants
+     */
+    private fun mapTheme(theme: GooglePayButtonTheme): Int {
+        return when (theme) {
+            GooglePayButtonTheme.DARK -> ButtonConstants.ButtonTheme.DARK
+            GooglePayButtonTheme.LIGHT -> ButtonConstants.ButtonTheme.LIGHT
+        }
+    }
+    
+    /**
+     * Creates allowed payment methods JSON for button configuration
+     */
+    private fun createAllowedPaymentMethodsJson(
+        allowedNetworks: org.json.JSONArray
+    ): String {
+        return org.json.JSONArray().apply {
+            put(org.json.JSONObject().apply {
+                put("type", PaymentConstants.PAYMENT_METHOD_CARD)
+                put("parameters", org.json.JSONObject().apply {
+                    put("allowedAuthMethods", org.json.JSONArray().apply {
+                        put(PaymentConstants.AUTH_PAN_ONLY)
+                        put(PaymentConstants.AUTH_CRYPTOGRAM_3DS)
+                    })
+                    put("allowedCardNetworks", allowedNetworks)
+                })
+            })
+        }.toString()
+    }
+}
+
+

package/android/src/main/java/com/margelo/nitro/pay/GooglePayRequestBuilder.kt

@@ -0,0 +1,170 @@
+package com.margelo.nitro.pay
+
+import com.google.android.gms.wallet.WalletConstants
+import org.json.JSONArray
+import org.json.JSONObject
+
+/**
+ * Builder for Google Pay API request objects
+ */
+object GooglePayRequestBuilder {
+    
+    /**
+     * Creates an IsReadyToPay request
+     */
+    fun createIsReadyToPayRequest(): JSONObject {
+        return JSONObject().apply {
+            put("apiVersion", PaymentConstants.API_VERSION)
+            put("apiVersionMinor", PaymentConstants.API_VERSION_MINOR)
+            put("allowedPaymentMethods", JSONArray().apply {
+                put(createBaseCardPaymentMethod())
+            })
+        }
+    }
+    
+    /**
+     * Creates a complete payment data request
+     */
+    fun createPaymentDataRequest(
+        request: PaymentRequest,
+        environment: Int
+    ): JSONObject {
+        return JSONObject().apply {
+            put("apiVersion", PaymentConstants.API_VERSION)
+            put("apiVersionMinor", PaymentConstants.API_VERSION_MINOR)
+            put("merchantInfo", createMerchantInfo(request, environment))
+            put("allowedPaymentMethods", JSONArray().apply {
+                put(createCardPaymentMethod(request, environment))
+            })
+            put("transactionInfo", createTransactionInfo(request))
+        }
+    }
+    
+    /**
+     * Creates merchant info object
+     */
+    private fun createMerchantInfo(
+        request: PaymentRequest,
+        environment: Int
+    ): JSONObject {
+        return JSONObject().apply {
+            put("merchantName", PaymentConstants.DEFAULT_MERCHANT_NAME)
+            // Add merchant ID only for PRODUCTION environment
+            if (environment == WalletConstants.ENVIRONMENT_PRODUCTION) {
+                put("merchantId", request.merchantIdentifier)
+            }
+        }
+    }
+    
+    /**
+     * Creates base card payment method (no tokenization)
+     */
+    private fun createBaseCardPaymentMethod(): JSONObject {
+        return JSONObject().apply {
+            put("type", PaymentConstants.PAYMENT_METHOD_CARD)
+            put("parameters", JSONObject().apply {
+                put("allowedAuthMethods", createAllowedAuthMethods())
+                put("allowedCardNetworks", createAllowedCardNetworks())
+            })
+        }
+    }
+    
+    /**
+     * Creates card payment method with tokenization
+     */
+    private fun createCardPaymentMethod(
+        request: PaymentRequest,
+        environment: Int
+    ): JSONObject {
+        val baseMethod = createBaseCardPaymentMethod()
+        baseMethod.put("tokenizationSpecification", createTokenizationSpec(request, environment))
+        return baseMethod
+    }
+    
+    /**
+     * Creates tokenization specification
+     */
+    private fun createTokenizationSpec(
+        request: PaymentRequest,
+        environment: Int
+    ): JSONObject {
+        return JSONObject().apply {
+            put("type", PaymentConstants.TOKENIZATION_PAYMENT_GATEWAY)
+            put("parameters", JSONObject().apply {
+                val isProduction = environment == WalletConstants.ENVIRONMENT_PRODUCTION
+                put("gateway", request.googlePayGateway ?: PaymentConstants.DEFAULT_GATEWAY)
+                put(
+                    "gatewayMerchantId",
+                    request.googlePayGatewayMerchantId 
+                        ?: if (isProduction) request.merchantIdentifier 
+                        else PaymentConstants.DEFAULT_GATEWAY_MERCHANT_ID
+                )
+            })
+        }
+    }
+    
+    /**
+     * Creates transaction info
+     */
+    private fun createTransactionInfo(request: PaymentRequest): JSONObject {
+        val totalAmount = request.paymentItems.sumOf { it.amount }
+        
+        return JSONObject().apply {
+            put("totalPriceStatus", PaymentConstants.TOTAL_PRICE_STATUS_FINAL)
+            put("totalPrice", String.format("%.2f", totalAmount))
+            put("totalPriceLabel", PaymentConstants.TOTAL_PRICE_LABEL_DEFAULT)
+            put("currencyCode", request.currencyCode)
+            put("countryCode", request.countryCode)
+            
+            // Add display items if present
+            if (request.paymentItems.isNotEmpty()) {
+                put("displayItems", createDisplayItems(request.paymentItems))
+            }
+        }
+    }
+    
+    /**
+     * Creates display items array
+     */
+    private fun createDisplayItems(items: Array<PaymentItem>): JSONArray {
+        return JSONArray().apply {
+            items.forEach { item ->
+                put(JSONObject().apply {
+                    put("label", item.label)
+                    put(
+                        "type",
+                        if (item.type == PaymentItemType.FINAL) 
+                            PaymentConstants.LINE_ITEM_TYPE 
+                        else 
+                            PaymentConstants.PENDING_TYPE
+                    )
+                    put("price", String.format("%.2f", item.amount))
+                })
+            }
+        }
+    }
+    
+    /**
+     * Creates allowed auth methods
+     */
+    private fun createAllowedAuthMethods(): JSONArray {
+        return JSONArray().apply {
+            put(PaymentConstants.AUTH_PAN_ONLY)
+            put(PaymentConstants.AUTH_CRYPTOGRAM_3DS)
+        }
+    }
+    
+    /**
+     * Creates allowed card networks
+     */
+    fun createAllowedCardNetworks(): JSONArray {
+        return JSONArray().apply {
+            put(PaymentConstants.NETWORK_VISA)
+            put(PaymentConstants.NETWORK_MASTERCARD)
+            put(PaymentConstants.NETWORK_AMEX)
+            put(PaymentConstants.NETWORK_DISCOVER)
+        }
+    }
+}
+
+

package/android/src/main/java/com/margelo/nitro/pay/HybridGooglePayButton.kt

@@ -0,0 +1,146 @@
+package com.margelo.nitro.pay
+
+import android.util.Log
+import android.view.View
+import android.view.ViewGroup
+import android.widget.FrameLayout
+import com.facebook.react.uimanager.ThemedReactContext
+import com.google.android.gms.wallet.button.PayButton
+
+/**
+ * Hybrid implementation of GooglePayButton view component
+ */
+class HybridGooglePayButton(context: ThemedReactContext) : HybridGooglePayButtonSpec() {
+    
+    // View state
+    private var payButton: PayButton? = null
+    private val container: FrameLayout = FrameLayout(context)
+    
+    // Configuration tracking for change detection
+    private var currentButtonType: GooglePayButtonType? = null
+    private var currentTheme: GooglePayButtonTheme? = null
+    private var currentRadius: Double? = null
+    
+    // Props
+    override var buttonType: GooglePayButtonType = GooglePayButtonType.BUY
+    override var theme: GooglePayButtonTheme = GooglePayButtonTheme.DARK
+    override var radius: Double? = null
+    override var onPress: (() -> Unit)? = null
+    
+    override var view: View = container
+    override val memorySize: Long get() = 0L
+    
+    init {
+        Log.d(PaymentConstants.TAG_GOOGLE_PAY_BUTTON, "Initializing Google Pay button")
+        setupButton()
+    }
+    
+    override fun afterUpdate() {
+        setupButton()
+    }
+    
+    // MARK: - Private helpers
+    
+    private fun setupButton() {
+        val context = container.context ?: return
+        
+        try {
+            if (shouldReuseButton()) {
+                updateExistingButton()
+                return
+            }
+            
+            recreateButton(context)
+            
+        } catch (e: Exception) {
+            Log.e(PaymentConstants.TAG_GOOGLE_PAY_BUTTON, "Error setting up button", e)
+            restoreExistingButton()
+        }
+    }
+    
+    /**
+     * Checks if the existing button can be reused
+     */
+    private fun shouldReuseButton(): Boolean {
+        val hasButton = payButton != null && payButton?.parent == container
+        val propsUnchanged = currentButtonType == buttonType &&
+                             currentTheme == theme &&
+                             currentRadius == radius
+        return hasButton && propsUnchanged
+    }
+    
+    /**
+     * Updates the click listener on existing button
+     */
+    private fun updateExistingButton() {
+        payButton?.setOnClickListener {
+            onPress?.invoke()
+        }
+        Log.d(PaymentConstants.TAG_GOOGLE_PAY_BUTTON, "Button reused - props unchanged")
+    }
+    
+    /**
+     * Recreates the button with new configuration
+     */
+    private fun recreateButton(context: android.content.Context) {
+        Log.d(
+            PaymentConstants.TAG_GOOGLE_PAY_BUTTON,
+            "Recreating button - type: $buttonType, theme: $theme, radius: $radius"
+        )
+        
+        // Remove existing button
+        container.removeAllViews()
+        
+        // Create new button
+        val newButton = GooglePayButtonFactory.createButton(
+            context,
+            buttonType,
+            theme,
+            radius,
+            onPress
+        )
+        
+        // Update state
+        payButton = newButton
+        currentButtonType = buttonType
+        currentTheme = theme
+        currentRadius = radius
+        
+        // Add to container
+        val layoutParams = FrameLayout.LayoutParams(
+            ViewGroup.LayoutParams.MATCH_PARENT,
+            ViewGroup.LayoutParams.MATCH_PARENT
+        )
+        container.addView(newButton, layoutParams)
+        container.requestLayout()
+        
+        Log.d(PaymentConstants.TAG_GOOGLE_PAY_BUTTON, "Button created successfully")
+    }
+    
+    /**
+     * Attempts to restore existing button if setup fails
+     */
+    private fun restoreExistingButton() {
+        payButton?.let { existingButton ->
+            try {
+                if (existingButton.parent == null) {
+                    container.removeAllViews()
+                    container.addView(
+                        existingButton,
+                        FrameLayout.LayoutParams(
+                            ViewGroup.LayoutParams.MATCH_PARENT,
+                            ViewGroup.LayoutParams.MATCH_PARENT
+                        )
+                    )
+                    Log.d(PaymentConstants.TAG_GOOGLE_PAY_BUTTON, "Restored existing button")
+                }
+            } catch (restoreException: Exception) {
+                Log.e(
+                    PaymentConstants.TAG_GOOGLE_PAY_BUTTON,
+                    "Failed to restore button",
+                    restoreException
+                )
+            }
+        }
+    }
+}

package/android/src/main/java/com/margelo/nitro/pay/HybridPaymentHandler.kt

@@ -0,0 +1,184 @@
+package com.margelo.nitro.pay
+
+import android.app.Activity
+import android.content.Intent
+import android.util.Log
+import com.facebook.react.bridge.ActivityEventListener
+import com.facebook.react.bridge.ReactApplicationContext
+import com.google.android.gms.wallet.AutoResolveHelper
+import com.google.android.gms.wallet.IsReadyToPayRequest
+import com.google.android.gms.wallet.PaymentData
+import com.google.android.gms.wallet.PaymentDataRequest
+import com.google.android.gms.wallet.PaymentsClient
+import com.google.android.gms.wallet.Wallet
+import com.google.android.gms.wallet.WalletConstants
+import com.margelo.nitro.core.Promise
+import com.margelo.nitro.NitroModules
+
+/**
+ * Hybrid implementation of PaymentHandler for Google Pay on Android
+ */
+class HybridPaymentHandler : HybridPaymentHandlerSpec(), ActivityEventListener {
+    
+    private val reactContext: ReactApplicationContext by lazy {
+        NitroModules.applicationContext as? ReactApplicationContext
+            ?: throw IllegalStateException("Application context is not ReactApplicationContext")
+    }
+    
+    private var paymentPromise: Promise<PaymentResult>? = null
+    private var currentEnvironment: Int = WalletConstants.ENVIRONMENT_TEST
+    
+    init {
+        reactContext.addActivityEventListener(this)
+    }
+    
+    override val memorySize: Long get() = 0L
+    
+    // MARK: - Public API
+    
+    override fun payServiceStatus(): PayServiceStatus {
+        return try {
+            val request = IsReadyToPayRequest.fromJson(
+                GooglePayRequestBuilder.createIsReadyToPayRequest().toString()
+            )
+            
+            val client = createPaymentsClient(currentEnvironment)
+            client.isReadyToPay(request) // Trigger async check
+            
+            // Return optimistic status (actual check is async)
+            PayServiceStatus(canMakePayments = true, canSetupCards = true)
+        } catch (e: Exception) {
+            Log.e(PaymentConstants.TAG_PAYMENT_HANDLER, "Error checking status", e)
+            PayServiceStatus(canMakePayments = false, canSetupCards = false)
+        }
+    }
+    
+    override fun canMakePayments(usingNetworks: Array<String>): Boolean {
+        return usingNetworks.any { network ->
+            PaymentConstants.SUPPORTED_NETWORKS.contains(network.lowercase())
+        }
+    }
+    
+    override fun startPayment(request: PaymentRequest): Promise<PaymentResult> {
+        val promise = Promise<PaymentResult>()
+        paymentPromise = promise
+        
+        try {
+            val environment = determineEnvironment(request.googlePayEnvironment)
+            currentEnvironment = environment
+            
+            val paymentDataRequest = GooglePayRequestBuilder.createPaymentDataRequest(
+                request,
+                environment
+            )
+            
+            logPaymentRequest(paymentDataRequest, environment)
+            
+            val activity = reactContext.currentActivity
+            if (activity == null) {
+                handlePaymentError("No activity available to show payment UI")
+                return promise
+            }
+            
+            launchPaymentUI(paymentDataRequest, activity, environment)
+            
+        } catch (e: Exception) {
+            Log.e(PaymentConstants.TAG_PAYMENT_HANDLER, "Failed to start payment", e)
+            handlePaymentError("Failed to start payment: ${e.message}")
+        }
+        
+        return promise
+    }
+    
+    // MARK: - ActivityEventListener
+    
+    override fun onActivityResult(
+        activity: Activity,
+        requestCode: Int,
+        resultCode: Int,
+        data: Intent?
+    ) {
+        if (requestCode != PaymentConstants.LOAD_PAYMENT_DATA_REQUEST_CODE) return
+        
+        when (resultCode) {
+            Activity.RESULT_OK -> {
+                data?.let { 
+                    PaymentData.getFromIntent(it)?.let { paymentData ->
+                        handlePaymentSuccess(paymentData)
+                    }
+                } ?: handlePaymentError("No payment data received")
+            }
+            Activity.RESULT_CANCELED -> {
+                Log.d(PaymentConstants.TAG_PAYMENT_HANDLER, "Payment cancelled by user")
+                handlePaymentError("Payment cancelled by user")
+            }
+            AutoResolveHelper.RESULT_ERROR -> {
+                val status = data?.let { AutoResolveHelper.getStatusFromIntent(it) }
+                val message = status?.statusMessage ?: "Unknown error"
+                Log.e(PaymentConstants.TAG_PAYMENT_HANDLER, "Payment error: $message")
+                handlePaymentError("Payment error: $message")
+            }
+            else -> {
+                handlePaymentError("Payment failed with result code: $resultCode")
+            }
+        }
+    }
+    
+    override fun onNewIntent(intent: Intent) {
+        // Not used for Google Pay
+    }
+    
+    // MARK: - Private helpers
+    
+    private fun createPaymentsClient(environment: Int): PaymentsClient {
+        val walletOptions = Wallet.WalletOptions.Builder()
+            .setEnvironment(environment)
+            .build()
+        return Wallet.getPaymentsClient(reactContext, walletOptions)
+    }
+    
+    private fun determineEnvironment(envConfig: GooglePayEnvironment?): Int {
+        return when (envConfig) {
+            GooglePayEnvironment.PRODUCTION -> WalletConstants.ENVIRONMENT_PRODUCTION
+            GooglePayEnvironment.TEST, null -> WalletConstants.ENVIRONMENT_TEST
+        }
+    }
+    
+    private fun launchPaymentUI(
+        paymentDataRequest: org.json.JSONObject,
+        activity: Activity,
+        environment: Int
+    ) {
+        val request = PaymentDataRequest.fromJson(paymentDataRequest.toString())
+        val client = createPaymentsClient(environment)
+        
+        AutoResolveHelper.resolveTask(
+            client.loadPaymentData(request),
+            activity,
+            PaymentConstants.LOAD_PAYMENT_DATA_REQUEST_CODE
+        )
+        
+        Log.d(PaymentConstants.TAG_PAYMENT_HANDLER, "Payment UI launched")
+    }
+    
+    private fun handlePaymentSuccess(paymentData: PaymentData) {
+        Log.d(PaymentConstants.TAG_PAYMENT_HANDLER, "Payment successful")
+        val result = PaymentMapper.mapPaymentDataToResult(paymentData)
+        paymentPromise?.resolve(result)
+        paymentPromise = null
+    }
+    
+    private fun handlePaymentError(errorMessage: String) {
+        val result = PaymentMapper.createErrorResult(errorMessage)
+        paymentPromise?.resolve(result)
+        paymentPromise = null
+    }
+    
+    private fun logPaymentRequest(request: org.json.JSONObject, environment: Int) {
+        Log.d(PaymentConstants.TAG_PAYMENT_HANDLER, "Payment request: $request")
+        Log.d(
+            PaymentConstants.TAG_PAYMENT_HANDLER,
+            "Environment: ${if (environment == WalletConstants.ENVIRONMENT_TEST) "TEST" else "PRODUCTION"}"
+        )
+    }
+}

package/android/src/main/java/com/margelo/nitro/pay/NitroPayPackage.kt

@@ -0,0 +1,26 @@
+package com.margelo.nitro.pay
+
+import com.facebook.react.BaseReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.model.ReactModuleInfoProvider
+import com.facebook.react.uimanager.ViewManager
+import com.margelo.nitro.pay.views.HybridGooglePayButtonManager
+
+class NitroPayPackage : BaseReactPackage() {
+    override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? = null
+
+    override fun getReactModuleInfoProvider(): ReactModuleInfoProvider = ReactModuleInfoProvider { HashMap() }
+
+    override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
+        val viewManagers = ArrayList<ViewManager<*, *>>()
+        viewManagers.add(HybridGooglePayButtonManager())
+        return viewManagers
+    }
+
+    companion object {
+        init {
+            NitroPayOnLoad.initializeNative()
+        }
+    }
+}