@primer-io/react-native 0.13.0-beta.1 → 0.15.2

package/android/build.gradle

@@ -37,7 +37,11 @@ android {
   }
 
   buildTypes {
+    debug {
+      consumerProguardFiles 'consumer-rules.pro'
+    }
     release {
+      consumerProguardFiles 'consumer-rules.pro'
       minifyEnabled false
     }
   }
@@ -127,6 +131,6 @@ dependencies {
   // noinspection GradleDynamicVersion
   api 'com.facebook.react:react-native:+'
   implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
-  implementation "org.jetbrains.kotlinx:kotlinx-serialization-json:1.2.2"
-  implementation 'io.primer:android:1.11.1'
+  implementation "org.jetbrains.kotlinx:kotlinx-serialization-json:1.3.1"
+  implementation 'io.primer:android:1.13.0'
 }

package/android/consumer-rules.pro

@@ -0,0 +1,12 @@
+-dontnote kotlinx.serialization.AnnotationsKt # core serialization annotations
+
+-keepclassmembers class kotlinx.serialization.json.** {
+    *** Companion;
+}
+-keepclasseswithmembers class kotlinx.serialization.json.** {
+    kotlinx.serialization.KSerializer serializer(...);
+}
+-keep,includedescriptorclasses class com.primerioreactnative.**$$serializer { *; }
+-keepclasseswithmembers class com.primerioreactnative.** {
+    kotlinx.serialization.KSerializer serializer(...);
+}

package/android/gradle.properties

@@ -1,4 +1,4 @@
-ReactNative_kotlinVersion=1.4.32
+ReactNative_kotlinVersion=1.5.0
 ReactNative_compileSdkVersion=29
 ReactNative_buildToolsVersion=29.0.2
 ReactNative_targetSdkVersion=29

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

@@ -1,235 +1,274 @@
 package com.primerioreactnative
 
-import android.content.Context
 import android.util.Log
-import com.facebook.react.bridge.Callback
-import com.facebook.react.bridge.ReactApplicationContext
-import com.facebook.react.bridge.ReactContextBaseJavaModule
-import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.bridge.*
+import com.facebook.react.modules.core.DeviceEventManagerModule
 import com.primerioreactnative.datamodels.*
+import com.primerioreactnative.utils.PrimerImplementedRNCallbacks
+import com.primerioreactnative.utils.errorTo
+import io.primer.android.PaymentMethodIntent
 import io.primer.android.Primer
-import io.primer.android.model.dto.*
+import io.primer.android.model.dto.PrimerConfig
+import io.primer.android.model.dto.PrimerPaymentMethod
 import kotlinx.serialization.decodeFromString
 import kotlinx.serialization.encodeToString
 import kotlinx.serialization.json.Json
-import kotlin.Error
+import org.json.JSONObject
 
-class PrimerRN(reactContext: ReactApplicationContext) :
-  ReactContextBaseJavaModule(reactContext) {
+
+class PrimerRN(reactContext: ReactApplicationContext) : ReactContextBaseJavaModule(reactContext) {
 
   private var settings: PrimerSettingsRN = PrimerSettingsRN()
   private var theme: PrimerThemeRN = PrimerThemeRN()
-  private var intent: PrimerIntentRN = PrimerIntentRN()
+  private var intent: PaymentMethodIntent? = null
+  private var paymentMethod: PrimerPaymentMethod? = null
 
   private var mListener = PrimerRNEventListener()
 
   private var sdkWasInitialised = false
-  private var haltExecution = false
 
   private val json = Json { ignoreUnknownKeys = true }
 
-  override fun getName(): String = "PrimerRN"
+  init {
+    mListener.sendEvent = { eventName, paramsJson -> sendEvent(eventName, paramsJson) }
+    mListener.sendError = { paramsJson -> checkoutFailed(paramsJson) }
+  }
+
+  override fun getName(): String = "NativePrimer"
 
   @ReactMethod
-  fun configureSettings(request: String) {
+  fun configureWithSettings(settingsStr: String, promise: Promise) {
     try {
-      Log.d("PrimerRN", "settings: $request")
-      val settings = json.decodeFromString<PrimerSettingsRN>(request)
+      Log.d("PrimerRN", "settings: $settingsStr")
+      val settings = json.decodeFromString<PrimerSettingsRN>(settingsStr)
       this.settings = settings
+      startSdk()
+      promise.resolve(null)
     } catch (e: Exception) {
       Log.e("PrimerRN", "configure settings error: $e")
-      val exception = PrimerErrorRN(
-        ErrorTypeRN.ParseJsonFailed,
-        "failed to parse settings.",
-      )
-      val encoded = json.encodeToString(exception)
-      mListener.onPrimerErrorQueue?.addRequestAndPoll(encoded)
-      haltExecution = true
+      val exception = ErrorTypeRN.ParseJsonFailed errorTo "failed to parse settings."
+      checkoutFailed(exception)
+      promise.reject(exception.errorId, exception.errorDescription, e)
     }
   }
 
   @ReactMethod
-  fun configureTheme(request: String) {
+  fun configureWithTheme(themeStr: String, promise: Promise) {
     try {
-      Log.d("PrimerRN", "theme: $request")
-      val theme = json.decodeFromString<PrimerThemeRN>(request)
+      Log.d("PrimerRN", "theme: $themeStr")
+      val theme = json.decodeFromString<PrimerThemeRN>(themeStr)
       this.theme = theme
+      startSdk()
+      promise.resolve(null)
     } catch (e: Exception) {
       Log.e("PrimerRN", "configure theme error: $e")
-      val exception = PrimerErrorRN(
-        ErrorTypeRN.ParseJsonFailed,
-        "failed to parse theme.",
-      )
-      val encoded = json.encodeToString(exception)
-      mListener.onPrimerErrorQueue?.addRequestAndPoll(encoded)
-      haltExecution = true
+      val exception = ErrorTypeRN.ParseJsonFailed errorTo "failed to parse theme."
+      checkoutFailed(exception)
+      promise.reject(exception.errorId, exception.errorDescription, e)
     }
   }
 
   @ReactMethod
-  fun configureIntent(request: String) {
+  fun showUniversalCheckout(promise: Promise) {
+    val exception = ErrorTypeRN.CheckoutFlowFailed errorTo
+      "This method is deprecated. Use the new showUniversalCheckoutWithClientToken method"
+    checkoutFailed(exception)
+    promise.reject(exception.errorId, exception.errorDescription)
+  }
+
+  @ReactMethod
+  fun showUniversalCheckoutWithClientToken(
+    clientToken: String,
+    promise: Promise
+  ) {
     try {
-      Log.d("PrimerRN", "intent: $request")
-      val intent = json.decodeFromString<PrimerIntentRN>(request)
-      this.intent = intent
+      Primer.instance.showUniversalCheckout(reactApplicationContext.applicationContext, clientToken)
+      promise.resolve(null)
     } catch (e: Exception) {
-      Log.e("PrimerRN", "configure intent error: $e")
-      val exception = PrimerErrorRN(
-        ErrorTypeRN.ParseJsonFailed,
-        "failed to parse intent.",
-      )
-      val encoded = json.encodeToString(exception)
-      mListener.onPrimerErrorQueue?.addRequestAndPoll(encoded)
-      haltExecution = true
+      val exception = ErrorTypeRN.CheckoutFlowFailed errorTo
+        "Primer SDK failed: ${e.message}"
+      checkoutFailed(exception)
+      promise.reject(exception.errorId, exception.errorDescription, e)
     }
   }
 
   @ReactMethod
-  fun configureOnTokenizeSuccess(callback: Callback) {
-    mListener.configureOnTokenizeSuccess(callback)
+  fun showVaultManager(promise: Promise) {
+    val exception = ErrorTypeRN.CheckoutFlowFailed errorTo
+      "This method is deprecated. Use the new showUniversalCheckoutWithClientToken method"
+    checkoutFailed(exception)
+    promise.reject(exception.errorId, exception.errorDescription)
   }
 
   @ReactMethod
-  fun configureOnClientSessionActions(callback: Callback) {
-    mListener.configureOnClientSessionActions(callback)
+  fun showVaultManager(clientToken: String, promise: Promise) {
+    try {
+      Primer.instance.showVaultManager(reactApplicationContext.applicationContext, clientToken)
+      promise.resolve(null)
+    } catch (e: Exception) {
+      val exception = ErrorTypeRN.CheckoutFlowFailed errorTo
+        "Primer SDK failed: ${e.message}"
+      checkoutFailed(exception)
+      promise.reject(exception.errorId, exception.errorDescription, e)
+    }
   }
 
   @ReactMethod
-  fun configureOnResumeSuccess(callback: Callback) {
-    mListener.configureOnResumeSuccess(callback)
+  fun showPaymentMethod(
+    clientToken: String,
+    paymentMethodTypeStr: String,
+    intentStr: String,
+    promise: Promise
+  ) {
+    try {
+      this.intent = PaymentMethodIntent.valueOf(intentStr)
+    } catch (e: Exception) {
+      val exception = ErrorTypeRN.ParseJsonFailed errorTo "failed to parse intent."
+      checkoutFailed(exception)
+      promise.reject(exception.errorId, exception.errorDescription, e)
+      return
+    }
+    try {
+      val paymentMethod = PrimerPaymentMethod.valueOf(paymentMethodTypeStr)
+      this.paymentMethod = paymentMethod
+    } catch (e: Exception) {
+      val exception = ErrorTypeRN.CheckoutFlowFailed errorTo "failed to parse payment method type."
+      checkoutFailed(exception)
+      promise.reject(exception.errorId, exception.errorDescription, e)
+      return
+    }
+
+    try {
+      val paymentMethod = this.paymentMethod ?: return
+      val intent = this.intent ?: return
+      Primer.instance.showPaymentMethod(
+        reactApplicationContext.applicationContext,
+        clientToken,
+        paymentMethod,
+        intent
+      )
+      promise.resolve(null)
+    } catch (e: Exception) {
+      val exception = ErrorTypeRN.CheckoutFlowFailed errorTo
+        "Primer SDK failed: ${e.message}"
+      checkoutFailed(exception)
+      promise.reject(exception.errorId, exception.errorDescription, e)
+    }
   }
 
   @ReactMethod
-  fun configureOnVaultSuccess(callback: Callback) {
-    mListener.configureOnVaultSuccess(callback)
+  fun handleNewClientToken(clientToken: String, promise: Promise) {
+    mListener.onClientTokenCallback(clientToken, null)
+    mListener.onClientSessionActions(clientToken, null)
+    mListener.onTokenizeSuccess(clientToken, null)
+    mListener.onResumeSuccess(clientToken, null)
+    removeCallbacksAndHandlers()
+    promise.resolve(null)
   }
 
   @ReactMethod
-  fun configureOnDismiss(callback: Callback) {
-    mListener.configureOnDismiss(callback)
+  fun handleError(errorStr: String, promise: Promise) {
+    try {
+      val err = json.decodeFromString<PrimerErrorRN>(errorStr)
+      mListener.onClientTokenCallback(null, err)
+      mListener.onClientSessionActions(null, err)
+      mListener.onTokenizeSuccess(null, err)
+      mListener.onResumeSuccess(null, err)
+      removeCallbacksAndHandlers()
+      promise.resolve(null)
+    } catch (e: Exception) {
+      val exception = PrimerErrorRN(
+        ErrorTypeRN.CheckoutFlowFailed.name,
+        "Primer SDK failed: ${e.message}"
+      )
+      checkoutFailed(exception)
+      promise.reject(exception.errorId, exception.errorDescription, e)
+    }
   }
 
   @ReactMethod
-  fun configureOnPrimerError(callback: Callback) {
-    mListener.configureOnPrimerError(callback)
+  fun handleSuccess(promise: Promise) {
+    try {
+      mListener.onClientTokenCallback(null, null)
+      mListener.onClientSessionActions(null, null)
+      mListener.onTokenizeSuccess(null, null)
+      mListener.onResumeSuccess(null, null)
+      removeCallbacksAndHandlers()
+      promise.resolve(null)
+    } catch (e: Exception) {
+      val exception = ErrorTypeRN.CheckoutFlowFailed errorTo
+        "Primer SDK failed: ${e.message}"
+      checkoutFailed(exception)
+      promise.reject(exception.errorId, exception.errorDescription, e)
+    }
   }
 
   @ReactMethod
-  fun configureOnSavedPaymentInstrumentsFetched(callback: Callback) {
-    mListener.configureOnSavedPaymentInstrumentsFetched(callback)
+  fun setImplementedRNCallbacks(implementedRNCallbacksStr: String, promise: Promise) {
+    try {
+      Log.d("PrimerRN", "implementedRNCallbacks: $implementedRNCallbacksStr")
+      val implementedRNCallbacks =
+        json.decodeFromString<PrimerImplementedRNCallbacks>(implementedRNCallbacksStr)
+      this.mListener.setImplementedCallbacks(implementedRNCallbacks)
+      promise.resolve(null)
+    } catch (e: Exception) {
+      val exception = ErrorTypeRN.ParseJsonFailed errorTo "Failed to parse implemented callbacks"
+      checkoutFailed(exception)
+      promise.reject(exception.errorId, exception.errorDescription, e)
+    }
   }
 
-  @ReactMethod
-  fun dispose() {
-    mListener = PrimerRNEventListener()
+  private fun removeCallbacksAndHandlers() {
+    mListener.removeCallbacksAndHandlers()
   }
 
-  private fun startSdk(token: String) {
+  private fun startSdk() {
     val theme = theme.format()
     val settings = settings.format()
     val config = PrimerConfig(theme, settings)
 
-    // todo: refactor with next version
-    mListener.completion = { error, clientToken ->
-      currentActivity?.let {
-        it.runOnUiThread {
-          if (error != null) {
-            mListener.resumeHandler?.handleError(Error(error))
-          } else {
-            if (clientToken == null) {
-              mListener.resumeHandler?.handleSuccess()
-            } else {
-              mListener.resumeHandler?.handleNewClientToken(clientToken)
-            }
-          }
-        }
-      }
-    }
-
-    mListener.actionCompletion = { error, clientToken ->
-      currentActivity?.let {
-        it.runOnUiThread {
-          if (error != null) {
-            mListener.actionResumeHandler?.handleError(Error(error))
-          } else {
-            mListener.actionResumeHandler?.handleClientToken(clientToken)
-          }
-        }
-      }
-    }
-
     Primer.instance.configure(config, mListener)
     sdkWasInitialised = true
   }
 
-  @ReactMethod
-  fun initialize(token: String) {
-    try {
-      if (haltExecution) {
-        haltExecution = false
-        return
-      }
-
-      Log.d("PrimerRN", "init with client token: $token")
-
-      startSdk(token)
-
-      val context = currentActivity as Context
+  private fun checkoutFailed(exception: PrimerErrorRN) {
+    val params = Arguments.createMap()
+    val errorJson = JSONObject(Json.encodeToString(exception))
+    val data = Arguments.createMap()
+    prepareData(data, errorJson)
+    params.putMap(Keys.ERROR, data)
+    sendEvent(PrimerEventsRN.OnError.string, params)
+  }
 
-      when (intent.vault) {
-        false -> Primer.instance.showUniversalCheckout(context, token)
-        true -> Primer.instance.showVaultManager(context, token)
-      }
-    } catch (e: Exception) {
-      Log.e("PrimerRN", "init error: $e")
-      val exception = PrimerErrorRN(
-        ErrorTypeRN.InitFailed,
-        "failed to initialise Primer SDK, error: $e",
-      )
-      val encoded = json.encodeToString(exception)
-      mListener.onPrimerErrorQueue?.addRequestAndPoll(encoded)
-    }
+  private fun sendEvent(name: String, params: WritableMap) {
+    reactApplicationContext.getJSModule(
+      DeviceEventManagerModule.RCTDeviceEventEmitter::class.java
+    ).emit(name, params)
   }
 
-  @ReactMethod
-  fun resume(request: String) {
-    try {
-      Log.d("PrimerRN", "resume: $request")
-      val data = json.decodeFromString<PrimerResumeRequest>(request)
-      mListener.completion?.invoke(data.error, data.token)
-    } catch (e: Exception) {
-      Log.e("PrimerRN", "configure settings error: $e")
-      val exception = PrimerErrorRN(
-        ErrorTypeRN.ParseJsonFailed,
-        "failed to parse settings.",
-      )
-      val encoded = json.encodeToString(exception)
-      mListener.onPrimerErrorQueue?.addRequestAndPoll(encoded)
-      haltExecution = true
-    }
+  private fun sendEvent(name: String, data: JSONObject?) {
+    val params = Arguments.createMap()
+    prepareData(params, data)
+    reactApplicationContext.getJSModule(
+      DeviceEventManagerModule.RCTDeviceEventEmitter::class.java
+    ).emit(name, params)
   }
 
-  @ReactMethod
-  fun actionResume(request: String) {
-    try {
-      Log.d("PrimerRN", "resume: $request")
-      val data = json.decodeFromString<PrimerResumeRequest>(request)
-      mListener.actionCompletion?.invoke(data.error, data.token)
-
-      mListener.actionCompletion = { error, clientToken ->
-        currentActivity?.let {
-          it.runOnUiThread {
-            if (error != null) {
-              mListener.actionResumeHandler?.handleError(Error(error))
-            } else {
-              mListener.actionResumeHandler?.handleClientToken(clientToken)
-            }
-          }
-        }
+  private fun prepareData(params: WritableMap, data: JSONObject?) {
+    data?.keys()?.forEach { key ->
+      when (val dataValue = data.opt(key)) {
+        is String -> params.putString(key, dataValue)
+        is Boolean -> params.putBoolean(key, dataValue)
+        is Double -> params.putDouble(key, dataValue)
+        is Int -> params.putInt(key, dataValue)
+        is JSONObject -> prepareData(params, dataValue)
+        else -> params.putNull(key)
       }
-
-    } catch (e: Exception) {
-      Log.e("PrimerRN", "configure settings error: $e")
     }
   }
 }
+
+internal object Keys {
+  const val ERROR = "error"
+  const val RESUME_TOKEN = "resumeToken"
+}