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

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

@@ -0,0 +1,344 @@
+package com.connexup.square.mobilepayment
+
+import com.connexup.square.mobilepayment.convert.getReaderChangeJsonValue
+import com.connexup.square.mobilepayment.convert.readableMap
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.WritableArray
+import com.facebook.react.bridge.WritableNativeArray
+import com.facebook.react.bridge.WritableNativeMap
+import com.squareup.sdk.mobilepayments.MobilePaymentsSdk
+import com.squareup.sdk.mobilepayments.cardreader.PairingErrorCode
+import com.squareup.sdk.mobilepayments.cardreader.PairingHandle
+import com.squareup.sdk.mobilepayments.cardreader.ReaderChangedEvent
+import com.squareup.sdk.mobilepayments.cardreader.ReaderInfo
+import com.squareup.sdk.mobilepayments.core.CallbackReference
+import com.squareup.sdk.mobilepayments.core.Result
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.launch
+import java.util.concurrent.ConcurrentHashMap
+
+private const val PRESENT_SETTINGS_ERROR_UNEXPECTED = "PRESENT_SETTINGS_ERROR_UNEXPECTED"
+
+/**
+ * Description:
+ * @author lukechen@chancetop.com
+ * @date 2026/2/2
+ */
+
+private const val PAIRING_ERROR_ALREADY_IN_PROGRESS = "PAIRING_ERROR_ALREADY_IN_PROGRESS"
+private const val PAIRING_ERROR_NOT_AUTHORIZED = "PAIRING_ERROR_NOT_AUTHORIZED"
+private const val PAIRING_ERROR_NOT_SUPPORTED = "PAIRING_ERROR_NOT_SUPPORTED"
+private const val PAIRING_ERROR_TIMED_OUT = "PAIRING_ERROR_TIMED_OUT"
+private const val PAIRING_ERROR_READER_ALREADY_PAIRING = "PAIRING_ERROR_READER_ALREADY_PAIRING"
+private const val PAIRING_ERROR_FAILED_TO_CONNECT = "PAIRING_ERROR_FAILED_TO_CONNECT"
+private const val PAIRING_ERROR_BLUETOOTH_DISABLED = "PAIRING_ERROR_BLUETOOTH_DISABLED"
+private const val PAIRING_ERROR_UPDATE_REQUIRED = "PAIRING_ERROR_UPDATE_REQUIRED"
+private const val PAIRING_ERROR_BLUETOOTH_PERMISSION_NOT_DETERMINED =
+  "PAIRING_ERROR_BLUETOOTH_PERMISSION_NOT_DETERMINED"
+private const val PAIRING_ERROR_BLUETOOTH_PERMISSION_RESTRICTED =
+  "PAIRING_ERROR_BLUETOOTH_PERMISSION_RESTRICTED"
+private const val PAIRING_ERROR_BLUETOOTH_PERMISSION_DENIED =
+  "PAIRING_ERROR_BLUETOOTH_PERMISSION_DENIED"
+private const val PAIRING_ERROR_BLUETOOTH_PERMISSION_UNKNOWN_CASE =
+  "PAIRING_ERROR_BLUETOOTH_PERMISSION_UNKNOWN_CASE"
+private const val PAIRING_ERROR_BLUETOOTH_NOT_SUPPORTED = "PAIRING_ERROR_BLUETOOTH_NOT_SUPPORTED"
+private const val PAIRING_ERROR_BLUETOOTH_NOT_READY = "PAIRING_ERROR_BLUETOOTH_NOT_READY"
+private const val PAIRING_ERROR_BLUETOOTH_RESETTING = "PAIRING_ERROR_BLUETOOTH_RESETTING"
+private const val PAIRING_ERROR_BONDING_REMOVED = "PAIRING_ERROR_BONDING_REMOVED"
+private const val PAIRING_ERROR_BLUETOOTH_UNKNOWN_ERROR = "PAIRING_ERROR_BLUETOOTH_UNKNOWN_ERROR"
+private const val PAIRING_ERROR_PAIRING_ERROR_APP_UPDATE_REQUIRED =
+  "PAIRING_ERROR_APP_UPDATE_REQUIRED"
+private const val PAIRING_ERROR_BOND_FAILED = "PAIRING_ERROR_BOND_FAILED"
+private const val PAIRING_ERROR_INTERNAL_FIRMWARE_ERROR = "PAIRING_ERROR_INTERNAL_FIRMWARE_ERROR"
+private const val PAIRING_ERROR_UNKNOWN_ERROR = "PAIRING_ERROR_UNKNOWN_ERROR"
+
+
+class MobilePaymentReader(reactContext: ReactApplicationContext) :
+  NativeMobilePaymentReaderSpec(reactContext) {
+
+  private val scope: CoroutineScope by lazy {
+    CoroutineScope(
+      SupervisorJob() + Dispatchers.Main
+    )
+  }
+
+  private var readerChangedCallbackRef: CallbackReference? = null
+
+  private var pairingHandle: PairingHandle? = null
+
+  private val readerStateRecord = ConcurrentHashMap<String, ReaderInfo.State>()
+
+  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
+    readerChangedCallbackRef?.clear()
+    readerChangedCallbackRef = null
+    readerStateRecord.clear()
+    super.invalidate()
+  }
+
+  private fun onSDKInitialize() {
+    readerChangedCallbackRef?.clear()
+    readerChangedCallbackRef = MobilePaymentsSdk.readerManager().setReaderChangedCallback {
+      onReaderChanged(it)
+    }
+  }
+
+  override fun isPairingInProgress(): Boolean {
+    return MobilePaymentsSdk.readerManager().isPairingInProgress
+  }
+
+  override fun readers(): WritableArray {
+    val result = WritableNativeArray()
+    MobilePaymentsSdk.readerManager().getReaders().forEach {
+      result.pushMap(it.readableMap)
+    }
+    return result
+  }
+
+  override fun bink(readerId: String, promise: Promise) {
+    scope.launch {
+      val reader = MobilePaymentsSdk.readerManager().getReader(readerId)
+      if (reader == null) {
+        promise.reject(
+          UNKNOWN_ERROR,
+          RNMobilePaymentErrorUtilities.createNativeModuleError(
+            UNKNOWN_ERROR,
+            "Reader Not Found",
+          ),
+          null,
+        )
+        return@launch
+      }
+      if (!reader.isBlinkable) {
+        promise.reject(
+          UNKNOWN_ERROR,
+          RNMobilePaymentErrorUtilities.createNativeModuleError(
+            UNKNOWN_ERROR,
+            "Reader Cannot Bink",
+          ),
+          null,
+        )
+        return@launch
+      }
+      try {
+        MobilePaymentsSdk.readerManager().blink(reader)
+        promise.resolve(null)
+      } catch (e: Exception) {
+        promise.reject(
+          UNKNOWN_ERROR,
+          RNMobilePaymentErrorUtilities.serializeErrorToJson(
+            UNKNOWN_ERROR,
+            e.message ?: "",
+          ),
+          e,
+        )
+      }
+    }
+  }
+
+  override fun forget(readerId: String, promise: Promise) {
+    scope.launch {
+      val reader = MobilePaymentsSdk.readerManager().getReader(readerId)
+      if (reader == null) {
+        promise.reject(
+          UNKNOWN_ERROR,
+          RNMobilePaymentErrorUtilities.createNativeModuleError(
+            UNKNOWN_ERROR,
+            "Reader Not Found",
+          ),
+          null,
+        )
+        return@launch
+      }
+      if (!reader.isForgettable) {
+        promise.reject(
+          UNKNOWN_ERROR,
+          RNMobilePaymentErrorUtilities.createNativeModuleError(
+            UNKNOWN_ERROR,
+            "Reader Cannot Forget",
+          ),
+          null,
+        )
+        return@launch
+      }
+      try {
+        MobilePaymentsSdk.readerManager().forget(reader)
+        promise.resolve(null)
+      } catch (e: Exception) {
+        promise.reject(
+          UNKNOWN_ERROR,
+          RNMobilePaymentErrorUtilities.serializeErrorToJson(
+            UNKNOWN_ERROR,
+            e.message ?: "",
+          ),
+          e,
+        )
+      }
+    }
+  }
+
+  override fun retryConnection(
+    readerId: String,
+    promise: Promise
+  ) {
+    scope.launch {
+      val reader = MobilePaymentsSdk.readerManager().getReader(readerId)
+      if (reader == null) {
+        promise.reject(
+          UNKNOWN_ERROR,
+          RNMobilePaymentErrorUtilities.createNativeModuleError(
+            UNKNOWN_ERROR,
+            "Reader Not Found",
+          ),
+          null,
+        )
+        return@launch
+      }
+      try {
+        MobilePaymentsSdk.readerManager().retryConnection(reader)
+        promise.resolve(null)
+      } catch (e: Exception) {
+        promise.reject(
+          UNKNOWN_ERROR,
+          RNMobilePaymentErrorUtilities.createNativeModuleError(
+            UNKNOWN_ERROR,
+            "Reader Cannot Retry Connection",
+          ),
+          null,
+        )
+      }
+    }
+  }
+
+  override fun startPairing(promise: Promise) {
+    scope.launch {
+      if (MobilePaymentsSdk.readerManager().isPairingInProgress) {
+        promise.reject(
+          PAIRING_ERROR_ALREADY_IN_PROGRESS,
+          RNMobilePaymentErrorUtilities.createNativeModuleError(
+            PAIRING_ERROR_ALREADY_IN_PROGRESS,
+          ),
+          null
+        )
+        return@launch
+      }
+      pairingHandle = MobilePaymentsSdk.readerManager().pairReader {
+        when (it) {
+          is Result.Failure -> {
+            sendPairingStatusChangeEvent("didFail", it)
+          }
+
+          is Result.Success -> {
+            if (it.value) {
+              sendPairingStatusChangeEvent("didSucceed", null)
+            }
+          }
+        }
+      }
+      promise.resolve(null)
+      sendPairingStatusChangeEvent("didBegin", null)
+    }
+  }
+
+  override fun stopPairing(promise: Promise) {
+    scope.launch {
+      val pairingHandle = pairingHandle
+      if (pairingHandle == null) {
+        promise.resolve(true)
+        return@launch
+      }
+
+      promise.resolve(
+        when (pairingHandle.stop()) {
+          PairingHandle.StopResult.ALREADY_COMPLETE -> false
+          PairingHandle.StopResult.STOPPED -> true
+        }
+      )
+    }
+  }
+
+  private fun onReaderChanged(event: ReaderChangedEvent) {
+    val eventName = when (event.change) {
+      ReaderChangedEvent.Change.ADDED -> {
+        "readerWasAdded"
+      }
+
+      ReaderChangedEvent.Change.REMOVED -> {
+        "readerWasRemoved"
+      }
+
+      else -> {
+        "readerDidChange"
+      }
+    }
+
+    val lastReaderState = readerStateRecord[event.reader.id]
+
+    val result = WritableNativeMap()
+    result.putString("name", eventName)
+    result.putMap("readerInfo", event.reader.readableMap)
+    result.putString("readerChange", event.getReaderChangeJsonValue(lastReaderState))
+    emitOnReaderChange(result)
+
+    if (event.change === ReaderChangedEvent.Change.REMOVED) {
+      readerStateRecord.remove(event.reader.id)
+    } else {
+      readerStateRecord[event.reader.id] = event.reader.state
+    }
+  }
+
+  private fun sendPairingStatusChangeEvent(
+    name: String,
+    error: Result.Failure<Boolean, PairingErrorCode>?
+  ) {
+    val result = WritableNativeMap()
+    result.putString("name", name)
+    if (error != null) {
+      val errorCode = when (error.errorCode) {
+        PairingErrorCode.BLUETOOTH_ALREADY_SCANNING -> PAIRING_ERROR_ALREADY_IN_PROGRESS
+        PairingErrorCode.BLUETOOTH_DISABLED -> PAIRING_ERROR_BLUETOOTH_DISABLED
+        PairingErrorCode.BLUETOOTH_PERMISSION_DENIED -> PAIRING_ERROR_BLUETOOTH_PERMISSION_DENIED
+        PairingErrorCode.BLUETOOTH_UNSUPPORTED -> PAIRING_ERROR_BLUETOOTH_NOT_SUPPORTED
+        PairingErrorCode.NOT_AUTHORIZED -> PAIRING_ERROR_NOT_AUTHORIZED
+        PairingErrorCode.TIMEOUT -> PAIRING_ERROR_TIMED_OUT
+        PairingErrorCode.USAGE_ERROR -> PAIRING_ERROR_BLUETOOTH_UNKNOWN_ERROR
+        PairingErrorCode.APP_UPDATE_REQUIRED -> PAIRING_ERROR_PAIRING_ERROR_APP_UPDATE_REQUIRED
+        PairingErrorCode.BOND_FAILED -> PAIRING_ERROR_BOND_FAILED
+        PairingErrorCode.INTERNAL_FIRMWARE_ERROR -> PAIRING_ERROR_INTERNAL_FIRMWARE_ERROR
+        PairingErrorCode.UNKNOWN_ERROR -> PAIRING_ERROR_UNKNOWN_ERROR
+      }
+      result.putString(
+        "error", RNMobilePaymentErrorUtilities.serializeErrorToJson(
+          errorCode,
+          error.errorMessage,
+          error.debugCode,
+          error.debugMessage
+        )
+      )
+      emitOnReaderPairingStatus(result)
+    }
+  }
+
+
+  companion object {
+    const val NAME = NativeMobilePaymentReaderSpec.NAME
+  }
+}

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

@@ -0,0 +1,47 @@
+package com.connexup.square.mobilepayment
+
+import android.app.Application
+import com.squareup.sdk.mobilepayments.MobilePaymentsSdk
+import kotlin.collections.mutableListOf
+import kotlin.getValue
+
+/**
+ * Description:
+ * @author lukechen@chancetop.com
+ * @date 2026/1/30
+ */
+
+fun interface InitializeListener {
+  fun onInitialize()
+}
+
+object MobilePaymentSDK {
+
+  var applicationId: String? = null
+    private set
+
+  val isInitialize get() = applicationId != null
+
+  private val initializeListeners by lazy {
+    mutableListOf<InitializeListener>()
+  }
+
+  fun addInitializeListener(listener: InitializeListener): InitializeListener {
+    this.initializeListeners.add(listener)
+    return listener
+  }
+
+  fun removeInitializeListener(listener: InitializeListener) {
+    this.initializeListeners.remove(listener)
+  }
+
+  fun initialize(applicationId: String, application: Application): Boolean {
+    if (this.isInitialize) {
+      return this.applicationId == applicationId
+    }
+    MobilePaymentsSdk.initialize(applicationId, application)
+    this.applicationId = applicationId
+    initializeListeners.forEach { it.onInitialize() }
+    return true
+  }
+}

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

@@ -0,0 +1,77 @@
+package com.connexup.square.mobilepayment
+
+import com.facebook.react.BaseReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.model.ReactModuleInfo
+import com.facebook.react.module.model.ReactModuleInfoProvider
+import java.util.HashMap
+
+class MobilePaymentSDKPackage : BaseReactPackage() {
+  override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? {
+    return when (name) {
+      MobilePaymentAuthorization.NAME -> {
+        MobilePaymentAuthorization(reactContext)
+      }
+
+      MobilePaymentPayment.NAME -> {
+        MobilePaymentPayment(reactContext)
+      }
+
+      MobilePaymentReader.NAME -> {
+        MobilePaymentReader(reactContext)
+      }
+
+      MobilePaymentSetting.NAME -> {
+        MobilePaymentSetting(reactContext)
+      }
+
+      else -> {
+        null
+      }
+    }
+  }
+
+  override fun getReactModuleInfoProvider(): ReactModuleInfoProvider {
+    return ReactModuleInfoProvider {
+      val moduleInfos: MutableMap<String, ReactModuleInfo> = HashMap()
+      moduleInfos[MobilePaymentAuthorization.NAME] = ReactModuleInfo(
+        name = MobilePaymentAuthorization.NAME,
+        className = MobilePaymentAuthorization.NAME,
+        canOverrideExistingModule = false,
+        needsEagerInit = false,
+        isCxxModule = false,
+        isTurboModule = true
+      )
+
+      moduleInfos[MobilePaymentPayment.NAME] = ReactModuleInfo(
+        name = MobilePaymentPayment.NAME,
+        className = MobilePaymentPayment.NAME,
+        canOverrideExistingModule = false,
+        needsEagerInit = false,
+        isCxxModule = false,
+        isTurboModule = true
+      )
+
+      moduleInfos[MobilePaymentReader.NAME] = ReactModuleInfo(
+        name = MobilePaymentReader.NAME,
+        className = MobilePaymentReader.NAME,
+        canOverrideExistingModule = false,
+        needsEagerInit = false,
+        isCxxModule = false,
+        isTurboModule = true
+      )
+
+      moduleInfos[MobilePaymentSetting.NAME] = ReactModuleInfo(
+        name = MobilePaymentSetting.NAME,
+        className = MobilePaymentSetting.NAME,
+        canOverrideExistingModule = false,
+        needsEagerInit = false,
+        isCxxModule = false,
+        isTurboModule = true
+      )
+
+      moduleInfos
+    }
+  }
+}

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

@@ -0,0 +1,144 @@
+package com.connexup.square.mobilepayment
+
+import com.connexup.square.mobilepayment.convert.jsonValue
+import com.connexup.square.mobilepayment.convert.writableMap
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.WritableMap
+import com.squareup.sdk.mobilepayments.MobilePaymentsSdk
+import com.squareup.sdk.mobilepayments.core.Result
+import com.squareup.sdk.mobilepayments.mockreader.ui.MockReaderUI
+import com.squareup.sdk.mobilepayments.settings.SettingsErrorCode
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.launch
+
+private const val INIT_SDK_ERROR = "INIT_SDK_ERROR"
+private const val PRESENT_SETTINGS_ERROR_UNEXPECTED = "PRESENT_SETTINGS_ERROR_UNEXPECTED"
+private const val PRESENT_MOCK_UI_ERROR_UNEXPECTED = "PRESENT_MOCK_UI_ERROR_UNEXPECTED"
+
+/**
+ * Description:
+ * @author lukechen@chancetop.com
+ * @date 2026/2/2
+ */
+class MobilePaymentSetting(reactContext: ReactApplicationContext) :
+  NativeMobilePaymentSettingSpec(reactContext) {
+
+  private val scope: CoroutineScope by lazy {
+    CoroutineScope(
+      SupervisorJob() + Dispatchers.Main
+    )
+  }
+
+  override fun applicationId(): String? {
+    return MobilePaymentSDK.applicationId
+  }
+
+  override fun initialize(applicationId: String, promise: Promise) {
+    scope.launch {
+      try {
+        val application = reactApplicationContextIfActiveOrWarn?.currentActivity?.application
+          ?: throw Exception("application is null")
+        val result = MobilePaymentSDK.initialize(
+          applicationId,
+          application
+        )
+        promise.resolve(result)
+      } catch (e: Exception) {
+        promise.reject(
+          INIT_SDK_ERROR,
+          RNMobilePaymentErrorUtilities.serializeErrorToJson(
+            code = INIT_SDK_ERROR,
+            message = e.message ?: "",
+          ),
+          e,
+        )
+      }
+    }
+  }
+
+  override fun sdkSettings(): WritableMap {
+    return MobilePaymentsSdk.settingsManager().getSdkSettings().writableMap
+  }
+
+  override fun paymentSettings(): WritableMap {
+    return MobilePaymentsSdk.settingsManager().getPaymentSettings().writableMap
+  }
+
+  override fun trackingConsentState(): String {
+    return MobilePaymentsSdk.settingsManager().trackingConsentState.jsonValue
+  }
+
+  override fun updateTrackingConsent(
+    granted: Boolean,
+    promise: Promise
+  ) {
+    scope.launch {
+      try {
+        MobilePaymentsSdk.settingsManager().updateTrackingConsent(granted)
+        promise.resolve(null)
+      } catch (e: MobilePaymentException) {
+        promise.reject(
+          UNKNOWN_ERROR,
+          RNMobilePaymentErrorUtilities.serializeErrorToJson(
+            UNKNOWN_ERROR,
+            e.message ?: "",
+          ),
+          e,
+        )
+      }
+    }
+  }
+
+  override fun presentSettings(promise: Promise) {
+    scope.launch {
+      MobilePaymentsSdk.settingsManager().showSettings {
+        when (it) {
+          is Result.Failure -> {
+            val errorCode = when (it.errorCode) {
+              SettingsErrorCode.USAGE_ERROR -> PRESENT_SETTINGS_ERROR_UNEXPECTED
+            }
+            promise.reject(
+              errorCode,
+              RNMobilePaymentErrorUtilities.serializeErrorToJson(
+                code = errorCode,
+                message = it.errorMessage,
+                debugCode = it.debugCode,
+                debugMessage = it.debugMessage
+              ),
+              MobilePaymentException(it.errorMessage),
+            )
+          }
+
+          is Result.Success -> {
+            promise.resolve(null)
+          }
+        }
+      }
+    }
+  }
+
+  override fun presentMockReaderUI(promise: Promise) {
+    scope.launch {
+      if (MobilePaymentsSdk.isSandboxEnvironment()) {
+        MockReaderUI.show()
+      }
+      promise.resolve(null)
+    }
+  }
+
+  override fun dismissMockReaderUI(promise: Promise) {
+    scope.launch {
+      if (MobilePaymentsSdk.isSandboxEnvironment()) {
+        MockReaderUI.hide()
+      }
+      promise.resolve(null)
+    }
+  }
+
+  companion object {
+    const val NAME = NativeMobilePaymentSettingSpec.NAME
+  }
+}

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

@@ -0,0 +1,46 @@
+package com.connexup.square.mobilepayment.convert
+
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.WritableArray
+import com.facebook.react.bridge.WritableNativeArray
+import com.facebook.react.bridge.WritableNativeMap
+import com.squareup.sdk.mobilepayments.payment.AdditionalPaymentMethod
+
+/**
+ * Description:
+ * @author lukechen@chancetop.com
+ * @date 2023/11/17
+ */
+
+val List<AdditionalPaymentMethod>.readableArray: ReadableArray
+  get() {
+    return this.writableArray
+  }
+
+val List<AdditionalPaymentMethod>.writableArray: WritableArray
+  get() {
+    val result = WritableNativeArray()
+    this.forEach {
+      result.pushMap(it.readableMap)
+    }
+    return result
+  }
+
+val AdditionalPaymentMethod.readableMap: ReadableMap
+  get() {
+    val result = WritableNativeMap()
+    val type = when (this.type) {
+      AdditionalPaymentMethod.Type.KEYED -> "KEYED"
+    }
+    result.putString("type", type)
+//        result.putString("name", MainApplication.context.getString(this.label))
+    return result
+  }
+
+fun String.toAdditionalPaymentMethodType(): AdditionalPaymentMethod.Type? {
+  return when (this) {
+    "KEYED" -> AdditionalPaymentMethod.Type.KEYED
+    else -> null
+  }
+}

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

@@ -0,0 +1,26 @@
+package com.connexup.square.mobilepayment.convert
+
+import com.squareup.sdk.mobilepayments.authorization.AuthorizationState
+
+
+/**
+ * Description:
+ * @author lukechen@chancetop.com
+ * @date 2023/11/16
+ */
+
+val AuthorizationState.jsonValue: String
+    get() {
+        if (this == AuthorizationState.newAuthorizedState()) {
+            return "AUTHORIZED"
+        }
+
+        if (this == AuthorizationState.newUnauthorizedState()) {
+            return "NOT_AUTHORIZED"
+        }
+
+        if (this == AuthorizationState.newUnauthorizedState()) {
+            return "NOT_AUTHORIZED"
+        }
+        return "UNKNOWN"
+    }