@connexup/react-native-square-mobile-payment-sdk 0.1.0

package/android/src/main/java/com/connexup/square/mobilepayment/MobilePaymentPayment.kt

@@ -0,0 +1,542 @@
+package com.connexup.square.mobilepayment
+
+import com.connexup.square.mobilepayment.convert.readableArray
+import com.connexup.square.mobilepayment.convert.readableMap
+import com.connexup.square.mobilepayment.convert.toAdditionalPaymentMethodType
+import com.connexup.square.mobilepayment.convert.toDelayAction
+import com.connexup.square.mobilepayment.convert.toMoney
+import com.connexup.square.mobilepayment.convert.toProcessingMode
+import com.connexup.square.mobilepayment.convert.writableArray
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.WritableArray
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.bridge.WritableNativeArray
+import com.facebook.react.bridge.WritableNativeMap
+import com.squareup.sdk.mobilepayments.MobilePaymentsSdk
+import com.squareup.sdk.mobilepayments.core.Result
+import com.squareup.sdk.mobilepayments.core.CallbackReference
+import com.squareup.sdk.mobilepayments.extensions.PaymentResult
+import com.squareup.sdk.mobilepayments.payment.AdditionalPaymentMethod
+import com.squareup.sdk.mobilepayments.payment.PaymentErrorCode
+import com.squareup.sdk.mobilepayments.payment.PaymentHandle
+import com.squareup.sdk.mobilepayments.payment.PaymentParameters
+import com.squareup.sdk.mobilepayments.payment.PromptMode
+import com.squareup.sdk.mobilepayments.payment.PromptParameters
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.launch
+
+/**
+ * Description:
+ * @author lukechen@chancetop.com
+ * @date 2026/2/2
+ */
+
+private const val PAYMENT_ERROR_NO_NETWORK = "PAYMENT_ERROR_NO_NETWORK"
+private const val PAYMENT_ERROR_NOT_AUTHORIZED = "PAYMENT_ERROR_NOT_AUTHORIZED"
+private const val PAYMENT_ERROR_INVALID_PAYMENT_PARAMETERS =
+  "PAYMENT_ERROR_INVALID_PAYMENT_PARAMETERS"
+private const val PAYMENT_ERROR_TIMED_OUT = "PAYMENT_ERROR_TIMED_OUT"
+private const val PAYMENT_ERROR_LOCATION_PERMISSION_NEEDED =
+  "PAYMENT_ERROR_LOCATION_PERMISSION_NEEDED"
+private const val PAYMENT_ERROR_PAYMENT_ALREADY_IN_PROGRESS =
+  "PAYMENT_ERROR_PAYMENT_ALREADY_IN_PROGRESS"
+private const val PAYMENT_ERROR_IDEMPOTENCY_KEY_REUSED = "PAYMENT_ERROR_IDEMPOTENCY_KEY_REUSED"
+private const val PAYMENT_ERROR_INVALID_PAYMENT_SOURCE = "PAYMENT_ERROR_INVALID_PAYMENT_SOURCE"
+private const val PAYMENT_ERROR_CANCELED = "PAYMENT_ERROR_CANCELED"
+private const val PAYMENT_CONSENT_NOT_PROVIDED = "PAYMENT_CONSENT_NOT_PROVIDED"
+private const val PAYMENT_DEVICE_CLOCK_SKEWED = "PAYMENT_DEVICE_CLOCK_SKEWED"
+private const val PAYMENT_ERROR_UNEXPECTED = "PAYMENT_ERROR_UNEXPECTED"
+
+class MobilePaymentPayment(reactContext: ReactApplicationContext) :
+  NativeMobilePaymentPaymentSpec(reactContext) {
+
+  private val scope: CoroutineScope by lazy {
+    CoroutineScope(
+      SupervisorJob() + Dispatchers.Main
+    )
+  }
+
+  private var availableCardEntryMethodChangedCallbackRef: CallbackReference? = null
+
+  private var initializeListener: InitializeListener? = null
+
+  override fun initialize() {
+    super.initialize()
+    this.initializeListener = MobilePaymentSDK.addInitializeListener {
+      onSDKInitialize()
+    }
+    if (MobilePaymentSDK.isInitialize) {
+      initializeListener?.onInitialize()
+    }
+  }
+
+  override fun invalidate() {
+    initializeListener?.let {
+      MobilePaymentSDK.removeInitializeListener(it)
+    }
+    initializeListener = null
+    availableCardEntryMethodChangedCallbackRef?.clear()
+    availableCardEntryMethodChangedCallbackRef = null
+    scope.launch {
+      MobilePaymentsSdk.paymentManager().currentPaymentHandle?.cancel()
+    }
+    super.invalidate()
+  }
+
+  private fun onSDKInitialize() {
+    availableCardEntryMethodChangedCallbackRef?.clear()
+    availableCardEntryMethodChangedCallbackRef =
+      MobilePaymentsSdk.paymentManager().setAvailableCardEntryMethodChangedCallback {
+        emitOnAvailableCardInputMethodsChange(it.readableArray)
+      }
+  }
+
+  override fun startPayment(
+    paymentParameters: ReadableMap,
+    promptParameters: ReadableMap,
+    promise: Promise
+  ) {
+    //TODO handle theme
+    scope.launch {
+      val paymentParametersMap = paymentParameters.toHashMap()
+
+      val allowCardSurcharge = paymentParametersMap["allowCardSurcharge"] as? Boolean
+      if (allowCardSurcharge == null) {
+        promise.reject(
+          PARAMS_ERROR, RNMobilePaymentErrorUtilities.createNativeModuleError(
+            PARAMS_ERROR,
+            "Params allowCardSurcharge Not Found"
+          ), null
+        )
+        return@launch
+      }
+
+      val paymentAttemptId = paymentParametersMap["paymentAttemptId"] as? String
+      if (paymentAttemptId == null) {
+        promise.reject(
+          PARAMS_ERROR, RNMobilePaymentErrorUtilities.createNativeModuleError(
+            PARAMS_ERROR,
+            "Params paymentAttemptId Not Found"
+          ), null
+        )
+        return@launch
+      }
+
+      val amountMoney =
+        (paymentParametersMap["amountMoney"] as? Map<String?, Any?>)?.toMoney()
+      if (amountMoney == null) {
+        promise.reject(
+          PARAMS_ERROR, RNMobilePaymentErrorUtilities.createNativeModuleError(
+            PARAMS_ERROR,
+            "Params amountMoney Not Found"
+          ), null
+        )
+        return@launch
+      }
+
+      val processingMode =
+        (paymentParametersMap["processingMode"] as? String)?.toProcessingMode()
+      if (processingMode == null) {
+        promise.reject(
+          PARAMS_ERROR, RNMobilePaymentErrorUtilities.createNativeModuleError(
+            PARAMS_ERROR,
+            "Params processingMode Not Found"
+          ), null
+        )
+        return@launch
+      }
+
+      var paymentParametersBuilder =
+        PaymentParameters.Builder(amountMoney, processingMode, allowCardSurcharge)
+          .paymentAttemptId(paymentAttemptId)
+
+      val acceptPartialAuthorization =
+        paymentParametersMap["acceptPartialAuthorization"] as? Boolean
+      if (acceptPartialAuthorization != null) {
+        paymentParametersBuilder =
+          paymentParametersBuilder.acceptPartialAuthorization(acceptPartialAuthorization)
+      }
+
+      val autocomplete = paymentParametersMap["autocomplete"] as? Boolean
+      if (autocomplete != null) {
+        paymentParametersBuilder =
+          paymentParametersBuilder.autocomplete(autocomplete)
+      }
+
+      val delayAction = (paymentParametersMap["delayAction"] as? String)?.toDelayAction()
+      if (delayAction != null) {
+        paymentParametersBuilder =
+          paymentParametersBuilder.delayAction(delayAction)
+      }
+
+      //TODO delayDuration logic
+      val delayDuration = (paymentParametersMap["delayDuration"] as? Number)?.toLong()
+      if (delayDuration != null) {
+        paymentParametersBuilder =
+          paymentParametersBuilder.delayDuration(delayDuration)
+      }
+
+      val tipMoney = (paymentParametersMap["tipMoney"] as? Map<String?, Any?>)?.toMoney()
+      if (tipMoney != null) {
+        paymentParametersBuilder =
+          paymentParametersBuilder.tipMoney(tipMoney)
+      }
+
+      val appFeeMoney =
+        (paymentParametersMap["appFeeMoney"] as? Map<String?, Any?>)?.toMoney()
+      if (appFeeMoney != null) {
+        paymentParametersBuilder =
+          paymentParametersBuilder.appFeeMoney(appFeeMoney)
+      }
+
+      val locationID = paymentParametersMap["locationID"] as? String
+      if (locationID != null) {
+        paymentParametersBuilder =
+          paymentParametersBuilder.locationId(locationID)
+      }
+
+      val orderID = paymentParametersMap["orderID"] as? String
+      if (orderID != null) {
+        paymentParametersBuilder =
+          paymentParametersBuilder.orderId(orderID)
+      }
+
+      val referenceID = paymentParametersMap["referenceID"] as? String
+      if (referenceID != null) {
+        paymentParametersBuilder =
+          paymentParametersBuilder.referenceId(referenceID)
+      }
+
+      val customerID = paymentParametersMap["customerID"] as? String
+      if (customerID != null) {
+        paymentParametersBuilder =
+          paymentParametersBuilder.customerId(customerID)
+      }
+
+      val teamMemberID = paymentParametersMap["teamMemberID"] as? String
+      if (teamMemberID != null) {
+        paymentParametersBuilder =
+          paymentParametersBuilder.teamMemberId(teamMemberID)
+      }
+
+      val note = paymentParametersMap["note"] as? String
+      if (note != null) {
+        paymentParametersBuilder =
+          paymentParametersBuilder.note(note)
+      }
+
+      val statementDescriptionIdentifier =
+        paymentParametersMap["statementDescriptionIdentifier"] as? String
+      if (statementDescriptionIdentifier != null) {
+        paymentParametersBuilder =
+          paymentParametersBuilder.statementDescription(statementDescriptionIdentifier)
+      }
+
+      val promptParametersMap = promptParameters.toHashMap()
+
+      val promptModeParams = promptParametersMap["mode"]
+      val promptMode = when (promptModeParams) {
+        "DEFAULT" -> PromptMode.DEFAULT
+        "CUSTOM" -> PromptMode.CUSTOM
+        else -> PromptMode.DEFAULT
+      }
+
+      //TODO improve this
+      val additionalMethodsParams = promptParametersMap["additionalMethods"]
+      val additionalMethods = when (additionalMethodsParams) {
+        "ALL" -> AdditionalPaymentMethod.allPaymentMethods
+        "KEYED" -> listOf(AdditionalPaymentMethod.Type.KEYED)
+        else -> AdditionalPaymentMethod.allPaymentMethods
+      }
+
+      MobilePaymentsSdk.paymentManager().currentPaymentHandle?.cancel()
+      MobilePaymentsSdk.paymentManager().startPaymentActivity(
+        paymentParametersBuilder.build(),
+        PromptParameters(promptMode, additionalMethods)
+      ) {
+        onPaymentCallback(it)
+      }
+      promise.resolve(null)
+    }
+  }
+
+  override fun availableCardInputMethods(): WritableArray {
+    return MobilePaymentsSdk.paymentManager().getAvailableCardEntryMethods().writableArray
+  }
+
+  override fun additionalPaymentMethods(): WritableArray {
+    return MobilePaymentsSdk.paymentManager().currentPaymentHandle?.additionalPaymentMethods?.writableArray
+      ?: WritableNativeArray()
+  }
+
+  override fun triggerPaymentWithAdditionalPaymentMethod(
+    paymentSource: ReadableMap,
+    promise: Promise
+  ) {
+    scope.launch {
+      val sourceType = paymentSource.getString("type")?.toAdditionalPaymentMethodType()
+      if (sourceType == null) {
+        promise.reject(
+          PARAMS_ERROR, RNMobilePaymentErrorUtilities.createNativeModuleError(
+            PARAMS_ERROR,
+            "Params sourceType Not Found"
+          ), null
+        )
+        return@launch
+      }
+
+      val paymentHandle = MobilePaymentsSdk.paymentManager().currentPaymentHandle
+      if (paymentHandle == null) {
+        promise.reject(
+          UNKNOWN_ERROR, RNMobilePaymentErrorUtilities.createNativeModuleError(
+            UNKNOWN_ERROR,
+            "PaymentHandle Not Found"
+          ), null
+        )
+        return@launch
+      }
+
+      val additionalPaymentMethod = paymentHandle.findMethod(sourceType)
+
+      if (additionalPaymentMethod == null) {
+        promise.reject(
+          UNKNOWN_ERROR, RNMobilePaymentErrorUtilities.createNativeModuleError(
+            UNKNOWN_ERROR,
+            "AdditionalPaymentMethod Not Found"
+          ), null
+        )
+        return@launch
+      }
+
+      try {
+        when (additionalPaymentMethod) {
+          is AdditionalPaymentMethod.KeyedMethod -> {
+            additionalPaymentMethod.trigger()
+          }
+
+          /*                    is AdditionalPaymentMethod.CardOnFileEntryMethod -> {
+                                  val cardID = paymentSource.getString("cardID")
+                                  if (cardID == null) {
+                                      promise.reject(
+                                          PARAMS_ERROR, RNMobilePaymentErrorUtilities.createNativeModuleError(
+                                              PARAMS_ERROR,
+                                              "Params cardID Not Found"
+                                          ), null
+                                      )
+                                      return@launch
+                                  }
+                                  val customerID = paymentSource.getString("customerID")
+                                  if (customerID == null) {
+                                      promise.reject(
+                                          PARAMS_ERROR, RNMobilePaymentErrorUtilities.createNativeModuleError(
+                                              PARAMS_ERROR,
+                                              "Params cardID Not Found"
+                                          ), null
+                                      )
+                                      return@launch
+                                  }
+                                  additionalPaymentMethod.trigger(cardID, customerID)
+                              }
+
+                              is AlternatePaymentMethod.CashEntryMethod -> {
+                                  val buyerSuppliedMoney = paymentSource.getMap("buyerSuppliedMoney")
+                                  if (buyerSuppliedMoney == null) {
+                                      promise.reject(
+                                          PARAMS_ERROR, RNMobilePaymentErrorUtilities.createNativeModuleError(
+                                              PARAMS_ERROR,
+                                              "Params buyerSuppliedMoney Not Found"
+                                          ), null
+                                      )
+                                      return@launch
+                                  }
+                                  val realBuyerSuppliedMoney = buyerSuppliedMoney.toMoney()
+                                  if (realBuyerSuppliedMoney == null) {
+                                      promise.reject(
+                                          PARAMS_ERROR, RNMobilePaymentErrorUtilities.createNativeModuleError(
+                                              PARAMS_ERROR,
+                                              "Params buyerSuppliedMoney error"
+                                          ), null
+                                      )
+                                      return@launch
+                                  }
+                                  additionalPaymentMethod.trigger(realBuyerSuppliedMoney)
+                              }
+
+                              is AlternatePaymentMethod.ExternalEntryMethod -> {
+                                  val externalTenderTyp = paymentSource.getString("externalTenderTyp")
+                                  if (externalTenderTyp == null) {
+                                      promise.reject(
+                                          PARAMS_ERROR, RNMobilePaymentErrorUtilities.createNativeModuleError(
+                                              PARAMS_ERROR,
+                                              "Params externalTenderTyp Not Found"
+                                          ), null
+                                      )
+                                      return@launch
+                                  }
+                                  val source = paymentSource.getString("source")
+                                  if (source == null) {
+                                      promise.reject(
+                                          PARAMS_ERROR, RNMobilePaymentErrorUtilities.createNativeModuleError(
+                                              PARAMS_ERROR,
+                                              "Params source Not Found"
+                                          ), null
+                                      )
+                                      return@launch
+                                  }
+                                  val sourceId = paymentSource.getString("sourceId")
+                                  val sourceFeeMoney = paymentSource.getMap("sourceFeeMoney")
+                                  //TODO sourceFeeMoney
+                                  var realSourceFeeMoney: Money? = null
+                                  if (sourceFeeMoney != null) {
+                                      realSourceFeeMoney = sourceFeeMoney.toMoney()
+                                      if (realSourceFeeMoney == null) {
+                                          promise.reject(
+                                              PARAMS_ERROR,
+                                              RNMobilePaymentErrorUtilities.createNativeModuleError(
+                                                  PARAMS_ERROR,
+                                                  "Params sourceFeeMoney error"
+                                              ),
+                                              null
+                                          )
+                                          return@launch
+                                      }
+                                  }
+                                  additionalPaymentMethod.trigger(
+                                      ExternalPaymentDetails.Builder(
+                                          externalTenderTyp,
+                                          source,
+                                          sourceId,
+                                          realSourceFeeMoney
+                                      ).build()
+                                  )
+                              }
+
+                              is AlternatePaymentMethod.HouseAccountEntryMethod -> {
+                                  val paymentSourceToken = paymentSource.getString("paymentSourceToken")
+                                  if (paymentSourceToken == null) {
+                                      promise.reject(
+                                          PARAMS_ERROR, RNMobilePaymentErrorUtilities.createNativeModuleError(
+                                              PARAMS_ERROR,
+                                              "Params paymentSourceToken Not Found"
+                                          ), null
+                                      )
+                                      return@launch
+                                  }
+                                  val customerId = paymentSource.getString("customerId")
+                                  if (customerId == null) {
+                                      promise.reject(
+                                          PARAMS_ERROR, RNMobilePaymentErrorUtilities.createNativeModuleError(
+                                              PARAMS_ERROR,
+                                              "Params customerId Not Found"
+                                          ), null
+                                      )
+                                      return@launch
+                                  }
+                                  additionalPaymentMethod.trigger(paymentSourceToken, customerId)
+                              }
+
+                              is AlternatePaymentMethod.ManualEntryMethod -> {
+                                  additionalPaymentMethod.trigger()
+                              }
+
+                              is AlternatePaymentMethod.QrScanMethod -> {
+                                  val tag =
+                                      additionalPaymentMethod.tag as? AlternatePaymentMethod.PaymentMethodTag.QrScanMethodTag
+                                  if (tag == null) {
+                                      promise.reject(
+                                          UNKNOWN_ERROR,
+                                          RNMobilePaymentErrorUtilities.createNativeModuleError(
+                                              UNKNOWN_ERROR,
+                                              "tag == null"
+                                          ),
+                                          null
+                                      )
+                                      return@launch
+                                  }
+                                  additionalPaymentMethod.trigger(tag)
+                              }*/
+        }
+      } catch (e: Exception) {
+        promise.reject(
+          UNKNOWN_ERROR, RNMobilePaymentErrorUtilities.createNativeModuleError(
+            UNKNOWN_ERROR,
+            e.message ?: "",
+          ), e
+        )
+      }
+    }
+  }
+
+  override fun currentPayment(): WritableMap? {
+    return null
+  }
+
+  override fun isCurrentPaymentCancelable(): Boolean {
+    val paymentHandle = MobilePaymentsSdk.paymentManager().currentPaymentHandle ?: return true
+    //TODO isCurrentPaymentCancelable
+    return true
+  }
+
+  override fun cancelCurrentPayment(promise: Promise) {
+    scope.launch {
+      val paymentHandle = MobilePaymentsSdk.paymentManager().currentPaymentHandle
+      if (paymentHandle == null) {
+        promise.resolve(true)
+        return@launch
+      }
+      promise.resolve(
+        when (paymentHandle.cancel()) {
+          PaymentHandle.CancelResult.NO_PAYMENT_IN_PROGRESS -> true
+          PaymentHandle.CancelResult.CANCELED -> true
+          PaymentHandle.CancelResult.NOT_CANCELABLE -> false
+        }
+      )
+    }
+  }
+
+  private fun onPaymentCallback(paymentResult: PaymentResult) {
+    val result = WritableNativeMap()
+
+    when (paymentResult) {
+      is Result.Failure -> {
+        val errorCode = when (paymentResult.errorCode) {
+          PaymentErrorCode.NOT_AUTHORIZED -> PAYMENT_ERROR_NOT_AUTHORIZED
+          PaymentErrorCode.TIMEOUT -> PAYMENT_ERROR_TIMED_OUT
+          PaymentErrorCode.LOCATION_SERVICES_DISABLED -> PAYMENT_ERROR_LOCATION_PERMISSION_NEEDED
+          PaymentErrorCode.USAGE_ERROR -> PAYMENT_ERROR_UNEXPECTED
+          PaymentErrorCode.DEVICE_CLOCK_SKEWED -> PAYMENT_DEVICE_CLOCK_SKEWED
+          PaymentErrorCode.CANCELED -> PAYMENT_ERROR_CANCELED
+          PaymentErrorCode.CONSENT_NOT_PROVIDED -> PAYMENT_CONSENT_NOT_PROVIDED
+        }
+        if (paymentResult.errorCode == PaymentErrorCode.CANCELED) {
+          result.putString("name", "didCancel")
+        } else {
+          result.putString("name", "didFail")
+          result.putString(
+            "error", RNMobilePaymentErrorUtilities.serializeErrorToJson(
+              errorCode,
+              paymentResult.errorMessage,
+              paymentResult.debugCode,
+              paymentResult.debugMessage
+            )
+          )
+        }
+      }
+
+      is Result.Success -> {
+        result.putString("name", "didFinish")
+        result.putMap("payment", paymentResult.value.readableMap)
+      }
+    }
+
+    this.emitOnPaymentFlowStatusChange(result)
+  }
+
+  companion object {
+    const val NAME = NativeMobilePaymentPaymentSpec.NAME
+  }
+}