@capacitor-community/stripe-terminal 6.4.0 → 6.4.1

package/android/src/main/java/com/getcapacitor/community/stripe/terminal/StripeTerminalPlugin.kt

@@ -0,0 +1,205 @@
+package com.getcapacitor.community.stripe.terminal
+
+import android.Manifest
+import android.os.Build
+import android.util.Log
+import androidx.annotation.RequiresApi
+import com.getcapacitor.JSObject
+import com.getcapacitor.PermissionState
+import com.getcapacitor.Plugin
+import com.getcapacitor.PluginCall
+import com.getcapacitor.PluginMethod
+import com.getcapacitor.annotation.CapacitorPlugin
+import com.getcapacitor.annotation.Permission
+import com.getcapacitor.annotation.PermissionCallback
+import com.stripe.stripeterminal.external.models.TerminalException
+
+@RequiresApi(api = Build.VERSION_CODES.S)
+@CapacitorPlugin(
+    name = "StripeTerminal",
+    permissions = [Permission(
+        alias = "location",
+        strings = [Manifest.permission.ACCESS_FINE_LOCATION]
+    ), Permission(
+        alias = "bluetooth_old",
+        strings = [Manifest.permission.BLUETOOTH, Manifest.permission.BLUETOOTH_ADMIN]
+    ), Permission(
+        alias = "bluetooth",
+        strings = [Manifest.permission.BLUETOOTH_SCAN, Manifest.permission.BLUETOOTH_CONNECT, Manifest.permission.BLUETOOTH_ADVERTISE]
+    )]
+)
+class StripeTerminalPlugin : Plugin() {
+    private val implementation = StripeTerminal(
+        { this.context },
+        { this.activity },
+        { eventName: String?, data: JSObject? -> this.notifyListeners(eventName, data) },
+        logTag
+    )
+
+    @PluginMethod
+    @Throws(TerminalException::class)
+    fun initialize(call: PluginCall) {
+        this._initialize(call)
+    }
+
+    @PluginMethod
+    fun setConnectionToken(call: PluginCall) {
+        implementation.setConnectionToken(call)
+    }
+
+    @PluginMethod
+    fun setSimulatorConfiguration(call: PluginCall) {
+        implementation.setSimulatorConfiguration(call)
+    }
+
+    @PermissionCallback
+    @Throws(TerminalException::class)
+    private fun locationPermsCallback(call: PluginCall) {
+        if (getPermissionState("location") == PermissionState.GRANTED) {
+            this._initialize(call)
+        } else {
+            requestPermissionForAlias("location", call, "locationPermsCallback")
+        }
+    }
+
+    @PermissionCallback
+    @Throws(TerminalException::class)
+    private fun bluetoothOldPermsCallback(call: PluginCall) {
+        if (getPermissionState("bluetooth_old") == PermissionState.GRANTED) {
+            if (call.methodName == "discoverReaders") {
+                this.discoverReaders(call)
+            } else {
+                this.connectReader(call)
+            }
+        } else {
+            requestPermissionForAlias("bluetooth_old", call, "bluetoothOldPermsCallback")
+        }
+    }
+
+    @PermissionCallback
+    @Throws(TerminalException::class)
+    private fun bluetoothPermsCallback(call: PluginCall) {
+        if (getPermissionState("bluetooth") == PermissionState.GRANTED) {
+            if (call.methodName == "discoverReaders") {
+                this.discoverReaders(call)
+            } else {
+                this.connectReader(call)
+            }
+        } else {
+            requestPermissionForAlias("bluetooth", call, "bluetoothPermsCallback")
+        }
+    }
+
+    @Throws(TerminalException::class)
+    private fun _initialize(call: PluginCall) {
+        if (getPermissionState("location") != PermissionState.GRANTED) {
+            requestPermissionForAlias("location", call, "locationPermsCallback")
+        } else {
+            Log.d("Capacitor:permission location", getPermissionState("location").toString())
+            implementation.initialize(call)
+        }
+    }
+
+    @PluginMethod(returnType = PluginMethod.RETURN_CALLBACK)
+    fun discoverReaders(call: PluginCall) {
+        if (call.getString("type") == TerminalConnectTypes.Bluetooth.webEventName || call.getString(
+                "type"
+            ) == TerminalConnectTypes.Simulated.webEventName
+        ) {
+            Log.d(
+                "Capacitor:permission bluetooth_old",
+                getPermissionState("bluetooth_old").toString()
+            )
+            Log.d("Capacitor:permission bluetooth", getPermissionState("bluetooth").toString())
+            if (Build.VERSION.SDK_INT <= 30 && getPermissionState("bluetooth_old") != PermissionState.GRANTED) {
+                requestPermissionForAlias("bluetooth_old", call, "bluetoothOldPermsCallback")
+            } else if (Build.VERSION.SDK_INT > 30 && getPermissionState("bluetooth") != PermissionState.GRANTED) {
+                requestPermissionForAlias("bluetooth", call, "bluetoothPermsCallback")
+            } else {
+                implementation.onDiscoverReaders(call)
+            }
+        } else {
+            implementation.onDiscoverReaders(call)
+        }
+    }
+
+    @PluginMethod
+    fun cancelDiscoverReaders(call: PluginCall) {
+        implementation.cancelDiscoverReaders(call)
+    }
+
+    @PluginMethod
+    fun connectReader(call: PluginCall) {
+        if (call.getString("type") == TerminalConnectTypes.Bluetooth.webEventName) {
+            Log.d(
+                "Capacitor:permission bluetooth_old",
+                getPermissionState("bluetooth_old").toString()
+            )
+            Log.d("Capacitor:permission bluetooth", getPermissionState("bluetooth").toString())
+            if (Build.VERSION.SDK_INT <= 30 && getPermissionState("bluetooth_old") != PermissionState.GRANTED) {
+                requestPermissionForAlias("bluetooth_old", call, "bluetoothOldPermsCallback")
+            } else if (Build.VERSION.SDK_INT > 30 && getPermissionState("bluetooth") != PermissionState.GRANTED) {
+                requestPermissionForAlias("bluetooth", call, "bluetoothPermsCallback")
+            } else {
+                implementation.connectReader(call)
+            }
+        } else {
+            implementation.connectReader(call)
+        }
+    }
+
+    @PluginMethod
+    fun getConnectedReader(call: PluginCall) {
+        implementation.getConnectedReader(call)
+    }
+
+    @PluginMethod
+    fun disconnectReader(call: PluginCall) {
+        implementation.disconnectReader(call)
+    }
+
+    @PluginMethod
+    fun collectPaymentMethod(call: PluginCall) {
+        implementation.collectPaymentMethod(call)
+    }
+
+    @PluginMethod
+    fun cancelCollectPaymentMethod(call: PluginCall) {
+        implementation.cancelCollectPaymentMethod(call)
+    }
+
+    @PluginMethod
+    fun confirmPaymentIntent(call: PluginCall) {
+        implementation.confirmPaymentIntent(call)
+    }
+
+    @PluginMethod
+    fun installAvailableUpdate(call: PluginCall) {
+        implementation.installAvailableUpdate(call)
+    }
+
+    @PluginMethod
+    fun cancelInstallUpdate(call: PluginCall) {
+        implementation.cancelInstallUpdate(call)
+    }
+
+    @PluginMethod
+    fun setReaderDisplay(call: PluginCall) {
+        implementation.setReaderDisplay(call)
+    }
+
+    @PluginMethod
+    fun clearReaderDisplay(call: PluginCall) {
+        implementation.clearReaderDisplay(call)
+    }
+
+    @PluginMethod
+    fun rebootReader(call: PluginCall) {
+        implementation.rebootReader(call)
+    }
+
+    @PluginMethod
+    fun cancelReaderReconnection(call: PluginCall) {
+        implementation.cancelReaderReconnection(call)
+    }
+}

package/android/src/main/java/com/getcapacitor/community/stripe/terminal/TokenProvider.kt

@@ -0,0 +1,85 @@
+package com.getcapacitor.community.stripe.terminal
+
+import android.content.Context
+import android.util.Log
+import androidx.core.util.Supplier
+import com.android.volley.Response
+import com.android.volley.toolbox.StringRequest
+import com.android.volley.toolbox.Volley
+import com.getcapacitor.JSObject
+import com.getcapacitor.PluginCall
+import com.google.android.gms.common.util.BiConsumer
+import com.stripe.stripeterminal.external.callable.ConnectionTokenCallback
+import com.stripe.stripeterminal.external.callable.ConnectionTokenProvider
+import com.stripe.stripeterminal.external.models.ConnectionTokenException
+import org.json.JSONException
+import org.json.JSONObject
+import java.util.Objects
+
+class TokenProvider(
+    protected var contextSupplier: Supplier<Context>,
+    protected val tokenProviderEndpoint: String,
+    protected var notifyListenersFunction: BiConsumer<String, JSObject>
+) : ConnectionTokenProvider {
+    private var pendingCallback: ArrayList<ConnectionTokenCallback> = ArrayList()
+
+    fun setConnectionToken(call: PluginCall) {
+        val token = call.getString("token", "")
+        if (pendingCallback.isNotEmpty()) {
+            val pending = pendingCallback.removeAt(0)
+            if (token == "") {
+                pending.onFailure(ConnectionTokenException("Missing `token` is empty"))
+                call.reject("Missing `token` is empty")
+            } else {
+                pending.onSuccess(token!!)
+                call.resolve()
+            }
+        } else {
+            call.reject("Stripe Terminal do not pending fetchConnectionToken")
+        }
+    }
+
+    override fun fetchConnectionToken(callback: ConnectionTokenCallback) {
+        if (this.tokenProviderEndpoint == "") {
+            pendingCallback.add(callback)
+            this.notifyListeners(
+                TerminalEnumEvent.RequestedConnectionToken.webEventName,
+                JSObject()
+            )
+        } else {
+            try {
+                val queue = Volley.newRequestQueue(contextSupplier.get())
+                val postRequest: StringRequest = object : StringRequest(
+                    Method.POST,
+                    this.tokenProviderEndpoint,
+                    Response.Listener { response ->
+                        try {
+                            val jsonObject = JSONObject(response)
+                            Log.d("TokenProvider", jsonObject.getString("secret"))
+                            callback.onSuccess(jsonObject.getString("secret"))
+                        } catch (e: JSONException) {
+                            callback.onFailure(ConnectionTokenException(Objects.requireNonNull(e.localizedMessage)))
+                            throw RuntimeException(e)
+                        }
+                    },
+                    Response.ErrorListener { e -> throw RuntimeException(e) }
+                ) {
+                    //                @Override
+                    //                protected Map<String,String> getParams(){
+                    //                    Map<String,String> params = new HashMap<>();
+                    //                    params.put("word","test");
+                    //                    return params;
+                    //                }
+                }
+
+                queue.add(postRequest)
+            } catch (e: Exception) {
+                callback.onFailure(ConnectionTokenException("Failed to fetch connection token", e))
+            }
+        }
+    }
+
+    protected fun notifyListeners(eventName: String?, data: JSObject?) {
+        notifyListenersFunction.accept(eventName!!, data!!)
+    }
+}

package/android/src/main/java/com/getcapacitor/community/stripe/terminal/helper/MetaData.kt

@@ -0,0 +1,24 @@
+package com.getcapacitor.community.stripe.terminal.helper
+
+import android.content.Context
+import android.content.pm.PackageManager
+import androidx.core.util.Supplier
+import com.getcapacitor.Logger
+
+class MetaData(protected var contextSupplier: Supplier<Context>) {
+    var enableIdentifier: Boolean = false
+
+    init {
+        try {
+            val appInfo = contextSupplier
+                .get()
+                .packageManager
+                .getApplicationInfo(contextSupplier.get().packageName, PackageManager.GET_META_DATA)
+
+            enableIdentifier =
+                appInfo.metaData.getBoolean("com.getcapacitor.community.stripe.enableIdentifier")
+        } catch (ignored: Exception) {
+            Logger.info("MetaData didn't be prepare fore Google Pay.")
+        }
+    }
+}

package/android/src/main/java/com/getcapacitor/community/stripe/terminal/helper/TerminalMappers.kt

@@ -0,0 +1,90 @@
+package com.getcapacitor.community.stripe.terminal.helper
+
+import com.getcapacitor.JSObject
+import com.stripe.stripeterminal.external.models.DeviceType
+import com.stripe.stripeterminal.external.models.Location
+import com.stripe.stripeterminal.external.models.LocationStatus
+import com.stripe.stripeterminal.external.models.Reader
+import com.stripe.stripeterminal.external.models.ReaderSoftwareUpdate
+
+class TerminalMappers {
+    fun mapFromLocation(location: Location?): JSObject {
+        if (location == null) {
+            return JSObject()
+        }
+
+        val address = JSObject()
+
+        if (location.address != null) {
+            address
+                .put("country", location.address!!.country)
+                .put("city", location.address!!.city)
+                .put("postalCode", location.address!!.postalCode)
+                .put("line1", location.address!!.line1)
+                .put("line2", location.address!!.line2)
+                .put("state", location.address!!.state)
+        }
+
+        return JSObject()
+            .put("id", location.id)
+            .put("displayName", location.displayName)
+            .put("address", address)
+            .put("livemode", location.livemode)
+    }
+
+    fun mapFromReaderSoftwareUpdate(update: ReaderSoftwareUpdate?): JSObject {
+        if (update == null) {
+            return JSObject()
+        }
+
+        return JSObject()
+            .put("deviceSoftwareVersion", update.version)
+            .put("estimatedUpdateTime", update.durationEstimate.toString())
+            .put("requiredAt", update.requiredAtMs)
+    }
+
+    fun mapFromLocationStatus(status: LocationStatus?): String {
+        if (status == null) {
+            return "UNKNOWN"
+        }
+
+        return when (status) {
+            LocationStatus.NOT_SET -> "NOT_SET"
+            LocationStatus.SET -> "SET"
+            LocationStatus.UNKNOWN -> "UNKNOWN"
+            else -> "UNKNOWN"
+        }
+    }
+
+    fun mapFromNetworkStatus(status: Reader.NetworkStatus?): String {
+        if (status == null) {
+            return "UNKNOWN"
+        }
+
+        return when (status) {
+            Reader.NetworkStatus.OFFLINE -> "OFFLINE"
+            Reader.NetworkStatus.ONLINE -> "ONLINE"
+            else -> "UNKNOWN"
+        }
+    }
+
+    fun mapFromDeviceType(type: DeviceType): String {
+        return when (type) {
+            DeviceType.CHIPPER_1X -> "chipper1X"
+            DeviceType.CHIPPER_2X -> "chipper2X"
+            DeviceType.TAP_TO_PAY_DEVICE -> "tapToPayDevice"
+            DeviceType.ETNA -> "etna"
+            DeviceType.STRIPE_M2 -> "stripeM2"
+            DeviceType.STRIPE_S700 -> "stripeS700"
+            DeviceType.STRIPE_S700_DEVKIT -> "stripeS700Devkit"
+            DeviceType.UNKNOWN -> "unknown"
+            DeviceType.VERIFONE_P400 -> "verifoneP400"
+            DeviceType.WISECUBE -> "wiseCube"
+            DeviceType.WISEPAD_3 -> "wisePad3"
+            DeviceType.WISEPAD_3S -> "wisePad3s"
+            DeviceType.WISEPOS_E -> "wisePosE"
+            DeviceType.WISEPOS_E_DEVKIT -> "wisePosEDevkit"
+            else -> throw IllegalArgumentException("Unknown DeviceType: $type")
+        }
+    }
+}

package/android/src/main/java/com/getcapacitor/community/stripe/terminal/models/Executor.kt

@@ -0,0 +1,22 @@
+package com.getcapacitor.community.stripe.terminal.models
+
+import android.app.Activity
+import android.content.Context
+import androidx.core.util.Supplier
+import com.getcapacitor.JSObject
+import com.google.android.gms.common.util.BiConsumer
+
+abstract class Executor(
+    protected var contextSupplier: Supplier<Context>,
+    protected val activitySupplier: Supplier<Activity>,
+    protected var notifyListenersFunction: BiConsumer<String, JSObject>,
+    pluginLogTag: String,
+    executorTag: String
+) {
+    protected val logTag: String = "$pluginLogTag|$executorTag"
+
+    // Eventually we can change the notification directly here!
+    protected fun notifyListeners(eventName: String, data: JSObject) {
+        notifyListenersFunction.accept(eventName, data)
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@capacitor-community/stripe-terminal",
-  "version": "6.4.0",
+  "version": "6.4.1",
   "engines": {
     "node": ">=18.0.0"
   },