@primer-io/react-native 2.0.1 → 2.1.0

package/android/build.gradle

@@ -137,5 +137,5 @@ dependencies {
   api 'com.facebook.react:react-native:+'
   implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
   implementation "org.jetbrains.kotlinx:kotlinx-serialization-json:1.3.3"
-  implementation 'io.primer:android:2.0.1'
+  implementation 'io.primer:android:2.1.0'
 }

package/android/src/main/java/com/primerioreactnative/PrimerCardNumberEditTextManager.kt

@@ -0,0 +1,83 @@
+package com.primerioreactnative
+
+import android.content.res.ColorStateList
+import android.graphics.Color
+import android.graphics.drawable.ColorDrawable
+import android.graphics.drawable.GradientDrawable
+import android.view.ViewGroup
+import android.widget.EditText
+import android.widget.LinearLayout
+import android.widget.TextView
+import com.facebook.drawee.backends.pipeline.Fresco
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.SimpleViewManager
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.ViewProps
+import com.facebook.react.uimanager.annotations.ReactProp
+import com.facebook.react.views.image.ReactImageView
+import io.primer.android.components.manager.PrimerCardManager
+import io.primer.android.components.manager.PrimerUniversalCheckoutCardManagerInterface
+import io.primer.android.components.ui.widgets.*
+
+val listOfTextInputs = mutableListOf<PrimerEditText>()
+
+class PrimerCardNumberEditTextManager : SimpleViewManager<PrimerCardNumberEditText>() {
+
+  override fun getName(): String {
+    return REACT_CLASS
+  }
+
+  override fun createViewInstance(reactContext: ThemedReactContext): PrimerCardNumberEditText {
+    val editText = PrimerCardNumberEditText(reactContext)
+    return editText
+  }
+
+  companion object {
+    const val REACT_CLASS = "PrimerCardNumberEditText"
+  }
+}
+
+class PrimerCardholderNameEditTextManager : SimpleViewManager<PrimerCardholderNameEditText>() {
+
+  override fun getName(): String {
+    return REACT_CLASS
+  }
+
+  override fun createViewInstance(reactContext: ThemedReactContext): PrimerCardholderNameEditText {
+    return PrimerCardholderNameEditText(reactContext)
+  }
+
+  companion object {
+    const val REACT_CLASS = "PrimerCardholderNameEditText"
+  }
+}
+
+class PrimerExpiryEditTextManager : SimpleViewManager<PrimerExpiryEditText>() {
+
+  override fun getName(): String {
+    return REACT_CLASS
+  }
+
+  override fun createViewInstance(reactContext: ThemedReactContext): PrimerExpiryEditText {
+    return PrimerExpiryEditText(reactContext)
+  }
+
+  companion object {
+    const val REACT_CLASS = "PrimerExpiryEditText"
+  }
+}
+
+class PrimerCvvEditTextManager : SimpleViewManager<PrimerCvvEditText>() {
+
+  override fun getName(): String {
+    return REACT_CLASS
+  }
+
+  override fun createViewInstance(reactContext: ThemedReactContext): PrimerCvvEditText {
+    return PrimerCvvEditText(reactContext)
+  }
+
+  companion object {
+    const val REACT_CLASS = "PrimerCvvEditText"
+  }
+}

package/android/src/main/java/com/primerioreactnative/PrimerRN.kt

@@ -16,9 +16,9 @@ import kotlinx.serialization.encodeToString
 import kotlinx.serialization.json.Json
 import org.json.JSONObject
 
-class PrimerRN(reactContext: ReactApplicationContext) : ReactContextBaseJavaModule(reactContext) {
+class PrimerRN(private val reactContext: ReactApplicationContext, private val json: Json) :
+  ReactContextBaseJavaModule(reactContext) {
   private var mListener = PrimerRNEventListener()
-  private val json = Json { ignoreUnknownKeys = true }
 
   init {
     mListener.sendEvent = { eventName, paramsJson -> sendEvent(eventName, paramsJson) }

package/android/src/main/java/com/primerioreactnative/PrimerRNHeadlessUniversalCheckout.kt

@@ -0,0 +1,244 @@
+package com.primerioreactnative
+
+import android.util.Log
+import androidx.core.content.ContextCompat
+import com.facebook.react.bridge.*
+import com.facebook.react.modules.core.DeviceEventManagerModule
+import com.primerioreactnative.datamodels.*
+import com.primerioreactnative.huc.assets.AssetsManager
+import com.primerioreactnative.huc.assets.AssetsManager.drawableToBitmap
+import com.primerioreactnative.huc.assets.AssetsManager.getFile
+import com.primerioreactnative.huc.events.PrimerHeadlessUniversalCheckoutEvent
+import com.primerioreactnative.utils.PrimerHeadlessUniversalCheckoutImplementedRNCallbacks
+import com.primerioreactnative.utils.convertJsonToMap
+import com.primerioreactnative.utils.errorTo
+import io.primer.android.ExperimentalPrimerApi
+import io.primer.android.components.PrimerHeadlessUniversalCheckout
+import io.primer.android.components.ui.assets.ImageType
+import io.primer.android.data.configuration.models.PaymentMethodType
+import io.primer.android.data.configuration.models.PrimerPaymentMethodType
+import kotlinx.serialization.decodeFromString
+import kotlinx.serialization.encodeToString
+import kotlinx.serialization.json.Json
+import org.json.JSONObject
+
+@ExperimentalPrimerApi
+class PrimerRNHeadlessUniversalCheckout(
+  private val reactContext: ReactApplicationContext,
+  private val json: Json,
+) : ReactContextBaseJavaModule(reactContext) {
+
+  private val listener = PrimerRNHeadlessUniversalCheckoutListener()
+
+  init {
+    listener.sendEvent = { eventName, paramsJson -> sendEvent(eventName, paramsJson) }
+    listener.sendError = { paramsJson -> onError(paramsJson) }
+    listener.sendErrorWithCheckoutData =
+      { paramsJson, checkoutData -> onError(paramsJson, checkoutData) }
+  }
+
+  override fun getName(): String {
+    return "PrimerHeadlessUniversalCheckout"
+  }
+
+  @ReactMethod
+  fun startWithClientToken(
+    clientToken: String,
+    settingsStr: String?,
+    errorCallback: Callback,
+    successCallback: Callback
+  ) {
+    listener.successCallback = successCallback
+    try {
+      val settings =
+        if (settingsStr.isNullOrBlank()) PrimerSettingsRN() else json.decodeFromString(
+          settingsStr
+        )
+      PrimerHeadlessUniversalCheckout.current.start(
+        reactContext,
+        clientToken,
+        settings.toPrimerSettings(),
+        listener
+      )
+    } catch (e: Exception) {
+      errorCallback.invoke(
+        json.encodeToString(
+          ErrorTypeRN.NativeBridgeFailed errorTo
+            "failed to initialise PrimerHeadlessUniversalCheckout SDK, error: $e",
+        )
+      )
+    }
+  }
+
+  @ReactMethod
+  fun showPaymentMethod(paymentMethodTypeStr: String, promise: Promise) {
+    val primerPaymentMethodType = PrimerPaymentMethodType.safeValueOf(paymentMethodTypeStr)
+    if (primerPaymentMethodType == PaymentMethodType.UNKNOWN) {
+      val exception =
+        ErrorTypeRN.NativeBridgeFailed errorTo "Payment method type $paymentMethodTypeStr is not valid."
+      onError(exception)
+      promise.reject(exception.errorId, exception.description)
+    } else {
+      PrimerHeadlessUniversalCheckout.current.showPaymentMethod(
+        reactContext,
+        primerPaymentMethodType
+      )
+      promise.resolve(null)
+    }
+  }
+
+  @ReactMethod
+  fun disposePrimerHeadlessUniversalCheckout() {
+    PrimerHeadlessUniversalCheckout.current.cleanup()
+    listener.removeCallbacksAndHandlers()
+  }
+
+  @ReactMethod
+  fun getAssetForPaymentMethodType(
+    paymentMethodType: String,
+    assetType: String,
+    errorCallback: Callback,
+    successCallback: Callback
+  ) {
+
+    val primerPaymentMethodType = PrimerPaymentMethodType.safeValueOf(paymentMethodType)
+    val type = ImageType.values().find { it.name.equals(assetType, ignoreCase = true) }
+    when {
+      primerPaymentMethodType == PaymentMethodType.UNKNOWN -> {
+        errorCallback.invoke(
+          json.encodeToString(
+            ErrorTypeRN.InvalidPaymentMethodType errorTo
+              "Asset for $paymentMethodType does not exist, make sure you don't have any typos."
+          )
+        )
+      }
+      type == null -> {
+        errorCallback.invoke(
+          json.encodeToString(
+            ErrorTypeRN.AssetMismatch errorTo
+              "You have provided assetType=$assetType, but variable assetType can be 'LOGO' or 'ICON'."
+          )
+        )
+      }
+      else -> {
+        PrimerHeadlessUniversalCheckout.getAsset(primerPaymentMethodType, type)?.let { resourceId ->
+          val file = getFile(reactContext, paymentMethodType)
+          AssetsManager.saveBitmapToFile(
+            file,
+            drawableToBitmap(ContextCompat.getDrawable(reactContext, resourceId)!!),
+          )
+          successCallback.invoke("file://${file.absolutePath}")
+        } ?: run {
+          errorCallback.invoke(
+            json.encodeToString(
+              ErrorTypeRN.AssetMissing errorTo
+                "Failed to find $assetType for $paymentMethodType"
+            )
+          )
+        }
+      }
+    }
+  }
+
+  // region tokenization handlers
+  @ReactMethod
+  fun handleTokenizationNewClientToken(newClientToken: String, promise: Promise) {
+    listener.handleTokenizationNewClientToken(newClientToken)
+    promise.resolve(null)
+  }
+
+  @ReactMethod
+  fun handleTokenizationSuccess(promise: Promise) {
+    listener.handleTokenizationSuccess(promise)
+  }
+
+  @ReactMethod
+  fun handleTokenizationFailure(errorMessage: String?, promise: Promise) {
+    listener.handleTokenizationFailure(errorMessage.orEmpty(), promise)
+  }
+  // endregion
+
+  // region resume handlers
+  @ReactMethod
+  fun handleResumeNewClientToken(newClientToken: String, promise: Promise) {
+    listener.handleResumeNewClientToken(newClientToken)
+    promise.resolve(null)
+  }
+
+  @ReactMethod
+  fun handleResumeSuccess(promise: Promise) {
+    listener.handleResumeSuccess(promise)
+  }
+
+  @ReactMethod
+  fun handleResumeFailure(errorMessage: String?, promise: Promise) {
+    listener.handleResumeFailure(errorMessage.orEmpty(), promise)
+  }
+  // endregion
+
+  // region payment handlers
+  @ReactMethod
+  fun handlePaymentCreationContinue(promise: Promise) {
+    listener.handlePaymentCreationContinue()
+    promise.resolve(null)
+  }
+
+  @ReactMethod
+  fun handlePaymentCreationAbort(errorMessage: String?, promise: Promise) {
+    listener.handlePaymentCreationAbort(errorMessage.orEmpty())
+    promise.resolve(null)
+  }
+  // endregion
+
+  @ReactMethod
+  fun setImplementedRNCallbacks(implementedRNCallbacksStr: String, promise: Promise) {
+    try {
+      Log.d(TAG, "implementedRNCallbacks: $implementedRNCallbacksStr")
+      val implementedRNCallbacks =
+        json.decodeFromString<PrimerHeadlessUniversalCheckoutImplementedRNCallbacks>(
+          implementedRNCallbacksStr
+        )
+      listener.setImplementedCallbacks(implementedRNCallbacks)
+      promise.resolve(null)
+    } catch (e: Exception) {
+      val exception =
+        ErrorTypeRN.NativeBridgeFailed errorTo "Implemented callbacks $implementedRNCallbacksStr is not valid."
+      onError(exception)
+      promise.reject(exception.errorId, exception.description, e)
+    }
+  }
+
+  private fun onError(exception: PrimerErrorRN, checkoutDataRN: PrimerCheckoutDataRN? = null) {
+    val params = Arguments.createMap()
+    val errorJson = JSONObject(Json.encodeToString(exception))
+    val errorData = prepareData(errorJson)
+    params.putMap(Keys.ERROR, errorData)
+    checkoutDataRN?.let {
+      val checkoutDataJson = JSONObject(Json.encodeToString(it))
+      val checkoutData = prepareData(checkoutDataJson)
+      params.putMap(Keys.CHECKOUT_DATA, checkoutData)
+    }
+    sendEvent(PrimerHeadlessUniversalCheckoutEvent.ON_ERROR.eventName, params)
+  }
+
+  private fun sendEvent(name: String, params: WritableMap) {
+    reactApplicationContext.getJSModule(
+      DeviceEventManagerModule.RCTDeviceEventEmitter::class.java
+    ).emit(name, params)
+  }
+
+  private fun sendEvent(name: String, data: JSONObject?) {
+    val params = prepareData(data)
+    reactApplicationContext.getJSModule(
+      DeviceEventManagerModule.RCTDeviceEventEmitter::class.java
+    ).emit(name, params)
+  }
+
+  private fun prepareData(data: JSONObject?): WritableMap {
+    return data?.let { convertJsonToMap(data) } ?: Arguments.createMap()
+  }
+
+  private companion object {
+    const val TAG = "PrimerHUC"
+  }
+}

package/android/src/main/java/com/primerioreactnative/PrimerRNHeadlessUniversalCheckoutListener.kt

@@ -0,0 +1,275 @@
+package com.primerioreactnative
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.Callback
+import com.facebook.react.bridge.Promise
+import com.primerioreactnative.datamodels.*
+import com.primerioreactnative.extensions.toPrimerCheckoutDataRN
+import com.primerioreactnative.extensions.toPrimerClientSessionRN
+import com.primerioreactnative.extensions.toPrimerPaymentMethodDataRN
+import com.primerioreactnative.huc.events.PrimerHeadlessUniversalCheckoutEvent
+import com.primerioreactnative.utils.PrimerHeadlessUniversalCheckoutImplementedRNCallbacks
+import com.primerioreactnative.utils.errorTo
+import io.primer.android.ExperimentalPrimerApi
+import io.primer.android.completion.PrimerPaymentCreationDecisionHandler
+import io.primer.android.completion.PrimerResumeDecisionHandler
+import io.primer.android.components.PrimerHeadlessUniversalCheckoutListener
+import io.primer.android.components.domain.core.models.PrimerHeadlessUniversalCheckoutPaymentMethod
+import io.primer.android.data.configuration.models.PrimerPaymentMethodType
+import io.primer.android.domain.PrimerCheckoutData
+import io.primer.android.domain.action.models.PrimerClientSession
+import io.primer.android.domain.error.models.PrimerError
+import io.primer.android.domain.tokenization.models.PrimerPaymentMethodData
+import io.primer.android.domain.tokenization.models.PrimerPaymentMethodTokenData
+import kotlinx.serialization.encodeToString
+import kotlinx.serialization.json.Json
+import org.json.JSONObject
+
+@OptIn(ExperimentalPrimerApi::class)
+class PrimerRNHeadlessUniversalCheckoutListener : PrimerHeadlessUniversalCheckoutListener {
+  private var paymentCreationDecisionHandler: ((errorMessage: String?) -> Unit)? = null
+  private var tokenizeSuccessDecisionHandler: ((resumeToken: String?, errorMessage: String?) -> Unit)? =
+    null
+  private var resumeSuccessDecisionHandler: ((resumeToken: String?, errorMessage: String?) -> Unit)? =
+    null
+  private var implementedRNCallbacks: PrimerHeadlessUniversalCheckoutImplementedRNCallbacks? = null
+
+  var sendEvent: ((eventName: String, paramsJson: JSONObject?) -> Unit)? = null
+
+  var sendError: ((error: PrimerErrorRN) -> Unit)? = null
+  var sendErrorWithCheckoutData: ((error: PrimerErrorRN, checkoutData: PrimerCheckoutDataRN?) -> Unit)? =
+    null
+
+  var successCallback: Callback? = null
+
+  override fun onAvailablePaymentMethodsLoaded(paymentMethods: List<PrimerHeadlessUniversalCheckoutPaymentMethod>) {
+    sendEvent?.invoke(
+      PrimerHeadlessUniversalCheckoutEvent.ON_HUC_AVAILABLE_PAYMENT_METHODS_LOADED.eventName,
+      JSONObject().apply {
+        put("paymentMethodTypes", paymentMethods.map { it.paymentMethodType.name })
+      }
+    )
+    successCallback?.invoke(
+      Arguments.fromList(paymentMethods.map { it.paymentMethodType.name })
+    )
+  }
+
+  override fun onPreparationStarted(paymentMethodType: PrimerPaymentMethodType) {
+    sendEvent?.invoke(
+      PrimerHeadlessUniversalCheckoutEvent.ON_HUC_PREPARE_START.eventName,
+      JSONObject(Json.encodeToString(PrimerPaymentMethodDataRN(paymentMethodType)))
+    )
+  }
+
+  override fun onPaymentMethodShowed(paymentMethodType: PrimerPaymentMethodType) {
+    sendEvent?.invoke(
+      PrimerHeadlessUniversalCheckoutEvent.ON_HUC_PAYMENT_METHOD_SHOW.eventName,
+      JSONObject(Json.encodeToString(PrimerPaymentMethodDataRN(paymentMethodType)))
+    )
+  }
+
+  override fun onTokenizationStarted(paymentMethodType: PrimerPaymentMethodType) {
+    sendEvent?.invoke(
+      PrimerHeadlessUniversalCheckoutEvent.ON_HUC_TOKENIZE_START.eventName,
+      JSONObject(Json.encodeToString(PrimerPaymentMethodDataRN(paymentMethodType)))
+    )
+  }
+
+  override fun onCheckoutCompleted(checkoutData: PrimerCheckoutData) {
+    if (implementedRNCallbacks?.isOnCheckoutCompleteImplemented == true) {
+      sendEvent?.invoke(
+        PrimerHeadlessUniversalCheckoutEvent.ON_CHECKOUT_COMPLETE.eventName,
+        JSONObject(Json.encodeToString(checkoutData.toPrimerCheckoutDataRN()))
+      )
+    } else {
+      sendError?.invoke(
+        ErrorTypeRN.NativeBridgeFailed
+          errorTo "Callback [onCheckoutComplete] should be implemented."
+      )
+    }
+  }
+
+  override fun onBeforePaymentCreated(
+    paymentMethodData: PrimerPaymentMethodData,
+    createPaymentHandler: PrimerPaymentCreationDecisionHandler
+  ) {
+    if (implementedRNCallbacks?.isOnBeforePaymentCreateImplemented == true) {
+      paymentCreationDecisionHandler = { errorMessage ->
+        when {
+          errorMessage != null -> createPaymentHandler.abortPaymentCreation(errorMessage.ifBlank { null })
+          else -> createPaymentHandler.continuePaymentCreation()
+        }
+      }
+      sendEvent?.invoke(
+        PrimerHeadlessUniversalCheckoutEvent.ON_BEFORE_PAYMENT_CREATE.eventName,
+        JSONObject(Json.encodeToString(paymentMethodData.toPrimerPaymentMethodDataRN()))
+      )
+    } else {
+      super.onBeforePaymentCreated(paymentMethodData, createPaymentHandler)
+    }
+  }
+
+  override fun onBeforeClientSessionUpdated() {
+    if (implementedRNCallbacks?.isOnBeforeClientSessionUpdateImplemented == true) {
+      sendEvent?.invoke(
+        PrimerHeadlessUniversalCheckoutEvent.ON_BEFORE_CLIENT_SESSION_UPDATE.eventName,
+        null
+      )
+    } else {
+      super.onBeforeClientSessionUpdated()
+    }
+  }
+
+  override fun onClientSessionUpdated(clientSession: PrimerClientSession) {
+    if (implementedRNCallbacks?.isOnClientSessionUpdateImplemented == true) {
+      sendEvent?.invoke(
+        PrimerHeadlessUniversalCheckoutEvent.ON_CLIENT_SESSION_UPDATE.eventName,
+        JSONObject(Json.encodeToString(clientSession.toPrimerClientSessionRN()))
+      )
+    } else {
+      super.onClientSessionUpdated(clientSession)
+    }
+  }
+
+  override fun onTokenizeSuccess(
+    paymentMethodTokenData: PrimerPaymentMethodTokenData,
+    decisionHandler: PrimerResumeDecisionHandler
+  ) {
+    if (implementedRNCallbacks?.isOnTokenizeSuccessImplemented == true) {
+      val token = PrimerPaymentInstrumentTokenRN.fromPaymentMethodToken(paymentMethodTokenData)
+      val request = JSONObject(Json.encodeToString(token))
+      tokenizeSuccessDecisionHandler = { newClientToken, err ->
+        when {
+          err != null -> decisionHandler.handleFailure(err.ifBlank { null })
+          newClientToken != null -> decisionHandler.continueWithNewClientToken(newClientToken)
+          else -> decisionHandler.handleSuccess()
+        }
+      }
+      sendEvent?.invoke(PrimerHeadlessUniversalCheckoutEvent.ON_TOKENIZE_SUCCESS.eventName, request)
+    } else {
+      sendError?.invoke(
+        ErrorTypeRN.NativeBridgeFailed
+          errorTo "Callback [onTokenizeSuccess] should be implemented."
+      )
+    }
+  }
+
+  override fun onResumeSuccess(
+    resumeToken: String,
+    decisionHandler: PrimerResumeDecisionHandler
+  ) {
+    if (implementedRNCallbacks?.isOnResumeSuccessImplemented == true) {
+      resumeSuccessDecisionHandler = { newClientToken, err ->
+        when {
+          err != null -> decisionHandler.handleFailure(err.ifBlank { null })
+          newClientToken != null -> decisionHandler.continueWithNewClientToken(newClientToken)
+          else -> decisionHandler.handleSuccess()
+        }
+      }
+
+      val resumeToken = mapOf(Keys.RESUME_TOKEN to resumeToken)
+      sendEvent?.invoke(
+        PrimerHeadlessUniversalCheckoutEvent.ON_RESUME_SUCCESS.eventName,
+        JSONObject(Json.encodeToString(resumeToken))
+      )
+    } else {
+      sendError?.invoke(
+        ErrorTypeRN.NativeBridgeFailed
+          errorTo "Callback [onResumeSuccess] should be implemented."
+      )
+    }
+  }
+
+  override fun onFailed(
+    error: PrimerError,
+    checkoutData: PrimerCheckoutData?,
+  ) {
+    if (implementedRNCallbacks?.isOnErrorImplemented == true) {
+      sendErrorWithCheckoutData?.invoke(
+        PrimerErrorRN(
+          error.errorId,
+          error.description,
+          error.recoverySuggestion
+        ), checkoutData?.toPrimerCheckoutDataRN()
+      )
+    } else {
+      super.onFailed(error, checkoutData)
+    }
+  }
+
+  override fun onFailed(error: PrimerError) {
+    if (implementedRNCallbacks?.isOnErrorImplemented == true) {
+      sendError?.invoke(PrimerErrorRN(error.errorId, error.description, error.recoverySuggestion))
+    } else {
+      super.onFailed(error)
+    }
+  }
+
+  // region tokenization handlers
+  fun handleTokenizationNewClientToken(newClientToken: String) {
+    tokenizeSuccessDecisionHandler?.invoke(newClientToken, null)
+    tokenizeSuccessDecisionHandler = null
+  }
+
+  fun handleTokenizationSuccess(promise: Promise) {
+    val error =
+      ErrorTypeRN.NativeBridgeFailed errorTo "PrimerTokenizationHandler's " +
+        "handleSuccess function is not available on HUC."
+    promise.reject(error.errorId, error.description)
+  }
+
+  fun handleTokenizationFailure(errorMessage: String, promise: Promise) {
+    val error =
+      ErrorTypeRN.NativeBridgeFailed errorTo "PrimerTokenizationHandler's " +
+        "handleFailure function is not available on HUC."
+    promise.reject(error.errorId, error.description)
+  }
+  // endregion
+
+  // region resume handlers
+  fun handleResumeNewClientToken(newClientToken: String) {
+    resumeSuccessDecisionHandler?.invoke(newClientToken, null)
+    resumeSuccessDecisionHandler = null
+  }
+
+  fun handleResumeSuccess(promise: Promise) {
+    val error =
+      ErrorTypeRN.NativeBridgeFailed errorTo "PrimerResumeHandler's " +
+        "handleSuccess function is not available on HUC."
+    promise.reject(error.errorId, error.description)
+  }
+
+  fun handleResumeFailure(errorMessage: String, promise: Promise) {
+    val error =
+      ErrorTypeRN.NativeBridgeFailed errorTo "PrimerResumeHandler's " +
+        "handleFailure function is not available on HUC."
+    promise.reject(error.errorId, error.description)
+  }
+  // endregion
+
+  // region payment create handlers
+  fun handlePaymentCreationContinue() {
+    paymentCreationDecisionHandler?.invoke(null)
+    paymentCreationDecisionHandler = null
+  }
+
+  fun handlePaymentCreationAbort(errorMessage: String) {
+    paymentCreationDecisionHandler?.invoke(errorMessage)
+    paymentCreationDecisionHandler = null
+  }
+  // endregion
+
+  fun setImplementedCallbacks(
+    implementedRNCallbacks:
+    PrimerHeadlessUniversalCheckoutImplementedRNCallbacks
+  ) {
+    this.implementedRNCallbacks = implementedRNCallbacks
+  }
+
+  fun removeCallbacksAndHandlers() {
+    paymentCreationDecisionHandler = null
+    tokenizeSuccessDecisionHandler = null
+    resumeSuccessDecisionHandler = null
+    implementedRNCallbacks = null
+  }
+}

package/android/src/main/java/com/primerioreactnative/ReactNativePackage.kt

@@ -4,15 +4,26 @@ import com.facebook.react.ReactPackage
 import com.facebook.react.bridge.NativeModule
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.uimanager.ViewManager
-
+import kotlinx.serialization.json.Json
 
 class ReactNativePackage : ReactPackage {
+
+  private val json = Json { ignoreUnknownKeys = true }
+
   override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
-    return listOf(PrimerRN(reactContext))
+    return listOf(
+      PrimerRN(reactContext, json),
+      PrimerRNHeadlessUniversalCheckout(reactContext, json)
+    )
   }
 
   override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
-    return emptyList()
+    return mutableListOf(
+      PrimerCardNumberEditTextManager(),
+      PrimerCardholderNameEditTextManager(),
+      PrimerExpiryEditTextManager(),
+      PrimerCvvEditTextManager(),
+    )
   }
 }
 

package/android/src/main/java/com/primerioreactnative/datamodels/PrimerErrorRN.kt

@@ -12,4 +12,7 @@ data class PrimerErrorRN(
 @Serializable
 enum class ErrorTypeRN(val errorId: String) {
   NativeBridgeFailed("native-bridge"),
+  AssetMissing("missing-asset"),
+  AssetMismatch("mismatch-asset"),
+  InvalidPaymentMethodType("invalid-payment-method-type")
 }