@primer-io/react-native 2.30.0 → 2.30.1

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

@@ -1,165 +1,199 @@
 package com.primerioreactnative
 
 import android.util.Log
-import com.facebook.react.bridge.*
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.bridge.WritableMap
 import com.facebook.react.modules.core.DeviceEventManagerModule
-import com.primerioreactnative.datamodels.*
 import com.primerioreactnative.components.events.PrimerHeadlessUniversalCheckoutEvent
+import com.primerioreactnative.datamodels.ErrorTypeRN
+import com.primerioreactnative.datamodels.PrimerCheckoutDataRN
+import com.primerioreactnative.datamodels.PrimerErrorRN
+import com.primerioreactnative.datamodels.PrimerSettingsRN
+import com.primerioreactnative.datamodels.toPrimerSettings
 import com.primerioreactnative.utils.PrimerHeadlessUniversalCheckoutImplementedRNCallbacks
 import com.primerioreactnative.utils.errorTo
 import com.primerioreactnative.utils.toWritableMap
-import io.primer.android.core.ExperimentalPrimerApi
 import io.primer.android.components.PrimerHeadlessUniversalCheckout
+import io.primer.android.core.ExperimentalPrimerApi
 import kotlinx.serialization.decodeFromString
 import kotlinx.serialization.encodeToString
 import kotlinx.serialization.json.Json
 import org.json.JSONObject
 
+@Suppress("TooManyFunctions")
 @ExperimentalPrimerApi
 class PrimerRNHeadlessUniversalCheckout(
-  private val reactContext: ReactApplicationContext,
-  private val json: Json,
+    private val reactContext: ReactApplicationContext,
+    private val json: Json,
 ) : ReactContextBaseJavaModule(reactContext) {
+    private val listener = PrimerRNHeadlessUniversalCheckoutListener(reactContext)
+
+    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?,
+        promise: Promise,
+    ) {
+        listener.successCallback = promise
+        try {
+            val settings =
+                if (settingsStr.isNullOrBlank()) {
+                    PrimerSettingsRN()
+                } else {
+                    json.decodeFromString(
+                        settingsStr,
+                    )
+                }
+            PrimerHeadlessUniversalCheckout.current.start(
+                reactContext,
+                clientToken,
+                settings.toPrimerSettings(reactContext),
+                listener,
+                listener,
+            )
+        } catch (e: Exception) {
+            promise.reject(
+                ErrorTypeRN.NativeBridgeFailed.errorId,
+                "failed to initialise PrimerHeadlessUniversalCheckout SDK, error: $e",
+            )
+        }
+    }
+
+    @ReactMethod
+    fun cleanUp(promise: Promise) {
+        PrimerHeadlessUniversalCheckout.current.cleanup()
+        listener.removeCallbacksAndHandlers()
+        promise.resolve(null)
+    }
+
+    // region tokenization handlers
+    @ReactMethod
+    fun handleTokenizationNewClientToken(
+        newClientToken: String,
+        promise: Promise,
+    ) {
+        listener.handleTokenizationNewClientToken(newClientToken)
+        promise.resolve(null)
+    }
+    // endregion
+
+    // region resume handlers
+    @ReactMethod
+    fun handleResumeNewClientToken(
+        newClientToken: String,
+        promise: Promise,
+    ) {
+        listener.handleResumeNewClientToken(newClientToken)
+        promise.resolve(null)
+    }
+    // endregion
 
-  private val listener = PrimerRNHeadlessUniversalCheckoutListener(reactContext)
-
-  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?,
-    promise: Promise
-  ) {
-    listener.successCallback = promise
-    try {
-      val settings =
-        if (settingsStr.isNullOrBlank()) PrimerSettingsRN() else json.decodeFromString(
-          settingsStr
-        )
-      PrimerHeadlessUniversalCheckout.current.start(
-        reactContext,
-        clientToken,
-        settings.toPrimerSettings(reactContext),
-        listener,
-        listener
-      )
-    } catch (e: Exception) {
-      promise.reject(
-        ErrorTypeRN.NativeBridgeFailed.errorId,
-        "failed to initialise PrimerHeadlessUniversalCheckout SDK, error: $e",
-      )
+    // region complete handlers
+    @ReactMethod
+    fun handleCompleteFlow(promise: Promise) {
+        promise.resolve(null)
     }
-  }
-
-  @ReactMethod
-  fun cleanUp(promise: Promise) {
-    PrimerHeadlessUniversalCheckout.current.cleanup()
-    listener.removeCallbacksAndHandlers()
-    promise.resolve(null)
-  }
-
-  // region tokenization handlers
-  @ReactMethod
-  fun handleTokenizationNewClientToken(newClientToken: String, promise: Promise) {
-    listener.handleTokenizationNewClientToken(newClientToken)
-    promise.resolve(null)
-  }
-  // endregion
-
-  // region resume handlers
-  @ReactMethod
-  fun handleResumeNewClientToken(newClientToken: String, promise: Promise) {
-    listener.handleResumeNewClientToken(newClientToken)
-    promise.resolve(null)
-  }
-  // endregion
-
-  // region complete handlers
-  @ReactMethod
-  fun handleCompleteFlow(promise: Promise) {
-    promise.resolve(null)
-  }
-  // endregion complete handlers
-
-  // 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)
+    // endregion complete handlers
+
+    // 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)
+        }
     }
-  }
-
-  @ReactMethod
-  fun addListener(eventName: String?) = Unit
-
-  @ReactMethod
-  fun removeListeners(count: Int?) = Unit
-
-  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)
+
+    @ReactMethod
+    fun addListener(eventName: String?) = Unit
+
+    @ReactMethod
+    fun removeListeners(count: Int?) = Unit
+
+    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.toWritableMap()
+    }
+
+    private companion object {
+        const val TAG = "PrimerHUC"
     }
-    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.toWritableMap()
-  }
-
-  private companion object {
-    const val TAG = "PrimerHUC"
-  }
 }