react-native-hyperswitch-dev-sdk 0.4.1

package/android/src/main/java/io/hyperswitch/utils/ConversionUtils.kt

@@ -0,0 +1,256 @@
+package io.hyperswitch.utils
+
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.ReadableType
+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 org.json.JSONArray
+import org.json.JSONException
+import org.json.JSONObject
+
+object ConversionUtils {
+
+    @JvmStatic
+    @Throws(JSONException::class)
+    fun convertJsonToMap(jsonObject: JSONObject): WritableMap {
+        val map = WritableNativeMap()
+
+        val iterator = jsonObject.keys()
+        while (iterator.hasNext()) {
+            val key = iterator.next()
+            val value = jsonObject.get(key)
+            if (value == null || value === JSONObject.NULL) {
+                map.putNull(key)
+                continue
+            }
+            when (value) {
+                is JSONObject -> map.putMap(key, convertJsonToMap(value))
+                is JSONArray -> map.putArray(key, convertJsonToArray(value))
+                is Boolean -> map.putBoolean(key, value)
+                is Int -> map.putInt(key, value)
+                is Long -> map.putDouble(key, value.toDouble())
+                is Float -> map.putDouble(key, value.toDouble())
+                is Double -> map.putDouble(key, value)
+                is String -> map.putString(key, value)
+                else -> map.putString(key, value.toString())
+            }
+        }
+        return map
+    }
+
+    @JvmStatic
+    @Throws(JSONException::class)
+    fun convertJsonToArray(jsonArray: JSONArray): WritableArray {
+        val array = WritableNativeArray()
+
+        for (i in 0 until jsonArray.length()) {
+            val value = jsonArray.get(i)
+            if (value == null || value === JSONObject.NULL) {
+                array.pushNull()
+                continue
+            }
+            when (value) {
+                is JSONObject -> array.pushMap(convertJsonToMap(value))
+                is JSONArray -> array.pushArray(convertJsonToArray(value))
+                is Boolean -> array.pushBoolean(value)
+                is Int -> array.pushInt(value)
+                is Long -> array.pushDouble(value.toDouble())
+                is Float -> array.pushDouble(value.toDouble())
+                is Double -> array.pushDouble(value)
+                is String -> array.pushString(value)
+                else -> array.pushString(value.toString())
+            }
+        }
+        return array
+    }
+
+    @JvmStatic
+    @Throws(JSONException::class)
+    fun convertMapToJson(readableMap: ReadableMap?): JSONObject {
+        if (readableMap == null) return JSONObject()
+        val obj = JSONObject()
+        val iterator = readableMap.keySetIterator()
+        while (iterator.hasNextKey()) {
+            val key = iterator.nextKey()
+            when (readableMap.getType(key)) {
+                ReadableType.Null -> obj.put(key, JSONObject.NULL)
+                ReadableType.Boolean -> obj.put(key, readableMap.getBoolean(key))
+                ReadableType.Number -> obj.put(key, readableMap.getDouble(key))
+                ReadableType.String -> obj.put(key, readableMap.getString(key))
+                ReadableType.Map -> obj.put(key, convertMapToJson(readableMap.getMap(key)))
+                ReadableType.Array -> obj.put(key, convertArrayToJson(readableMap.getArray(key)))
+            }
+        }
+        return obj
+    }
+
+    /**
+     * Recursively convert a [ReadableMap] into a plain [Map]<String, Any>.
+     * Nested maps and arrays are converted recursively so that callers never
+     * receive raw [org.json.JSONObject] / [org.json.JSONArray] values.
+     */
+    @JvmStatic
+    fun readableMapToMap(readableMap: ReadableMap?): Map<String, Any> {
+        if (readableMap == null) return emptyMap()
+        val result = mutableMapOf<String, Any>()
+        val iterator = readableMap.keySetIterator()
+        while (iterator.hasNextKey()) {
+            val key = iterator.nextKey()
+            when (readableMap.getType(key)) {
+                ReadableType.Null -> {}
+                ReadableType.Boolean -> result[key] = readableMap.getBoolean(key)
+                ReadableType.Number -> result[key] = readableMap.getDouble(key)
+                ReadableType.String -> result[key] = readableMap.getString(key) ?: ""
+                ReadableType.Map -> result[key] = readableMapToMap(readableMap.getMap(key))
+                ReadableType.Array -> result[key] = readableArrayToList(readableMap.getArray(key))
+            }
+        }
+        return result
+    }
+
+    @JvmStatic
+    fun readableArrayToList(readableArray: ReadableArray?): List<Any> {
+        if (readableArray == null) return emptyList()
+        val result = mutableListOf<Any>()
+        for (i in 0 until readableArray.size()) {
+            when (readableArray.getType(i)) {
+                ReadableType.Null -> {}
+                ReadableType.Boolean -> result.add(readableArray.getBoolean(i))
+                ReadableType.Number -> result.add(readableArray.getDouble(i))
+                ReadableType.String -> result.add(readableArray.getString(i) ?: "")
+                ReadableType.Map -> result.add(readableMapToMap(readableArray.getMap(i)))
+                ReadableType.Array -> result.add(readableArrayToList(readableArray.getArray(i)))
+            }
+        }
+        return result
+    }
+
+    /**
+     * Recursively convert a plain [Map] into a [WritableMap] (ReadableMap).
+     * Mirrors the inverse of [readableMapToMap].
+     */
+    @JvmStatic
+    fun convertMapToReadableMap(map: Map<*, *>): WritableMap {
+        val writableMap = WritableNativeMap()
+        for ((key, value) in map) {
+            val k = key?.toString() ?: continue
+            when (value) {
+                null -> writableMap.putNull(k)
+                is Boolean -> writableMap.putBoolean(k, value)
+                is Int -> writableMap.putInt(k, value)
+                is Long -> writableMap.putDouble(k, value.toDouble())
+                is Float -> writableMap.putDouble(k, value.toDouble())
+                is Double -> writableMap.putDouble(k, value)
+                is String -> writableMap.putString(k, value)
+                is Map<*, *> -> writableMap.putMap(k, convertMapToReadableMap(value))
+                is List<*> -> writableMap.putArray(k, convertListToReadableArray(value))
+                else -> writableMap.putString(k, value.toString())
+            }
+        }
+        return writableMap
+    }
+
+    /**
+     * Recursively convert a plain [List] into a [WritableArray] (ReadableArray).
+     */
+    @JvmStatic
+    fun convertListToReadableArray(list: List<*>): WritableArray {
+        val writableArray = WritableNativeArray()
+        for (value in list) {
+            when (value) {
+                null -> writableArray.pushNull()
+                is Boolean -> writableArray.pushBoolean(value)
+                is Int -> writableArray.pushInt(value)
+                is Long -> writableArray.pushDouble(value.toDouble())
+                is Float -> writableArray.pushDouble(value.toDouble())
+                is Double -> writableArray.pushDouble(value)
+                is String -> writableArray.pushString(value)
+                is Map<*, *> -> writableArray.pushMap(convertMapToReadableMap(value))
+                is List<*> -> writableArray.pushArray(convertListToReadableArray(value))
+                else -> writableArray.pushString(value.toString())
+            }
+        }
+        return writableArray
+    }
+
+    @JvmStatic
+    @Throws(JSONException::class)
+    fun convertArrayToJson(readableArray: ReadableArray?): JSONArray {
+        if (readableArray == null) return JSONArray()
+        val array = JSONArray()
+        for (i in 0 until readableArray.size()) {
+            when (readableArray.getType(i)) {
+                ReadableType.Null -> {}
+                ReadableType.Boolean -> array.put(readableArray.getBoolean(i))
+                ReadableType.Number -> array.put(readableArray.getDouble(i))
+                ReadableType.String -> array.put(readableArray.getString(i))
+                ReadableType.Map -> array.put(convertMapToJson(readableArray.getMap(i)))
+                ReadableType.Array -> array.put(convertArrayToJson(readableArray.getArray(i)))
+            }
+        }
+        return array
+    }
+
+  @JvmStatic
+  @Throws(JSONException::class)
+  fun convertMapToJson(map: Map<*, *>?): JSONObject {
+    if (map == null) return JSONObject()
+
+    val jsonObject = JSONObject()
+
+    for ((key, value) in map) {
+      val jsonKey = key?.toString() ?: continue
+      jsonObject.put(jsonKey, convertValueToJson(value))
+    }
+
+    return jsonObject
+  }
+
+  @JvmStatic
+  @Throws(JSONException::class)
+  fun convertListToJson(list: List<*>?): JSONArray {
+    if (list == null) return JSONArray()
+
+    val jsonArray = JSONArray()
+
+    for (value in list) {
+      jsonArray.put(convertValueToJson(value))
+    }
+
+    return jsonArray
+  }
+
+  @JvmStatic
+  @Throws(JSONException::class)
+  private fun convertValueToJson(value: Any?): Any {
+    return when (value) {
+      null -> JSONObject.NULL
+
+      is JSONObject,
+      is JSONArray,
+      is Boolean,
+      is String,
+      is Int,
+      is Long,
+      is Float,
+      is Double,
+      is Short,
+      is Byte -> value
+
+      is Map<*, *> -> convertMapToJson(value)
+      is List<*> -> convertListToJson(value)
+      is Array<*> -> convertListToJson(value.toList())
+
+      is IntArray -> JSONArray(value.toList())
+      is LongArray -> JSONArray(value.toList())
+      is DoubleArray -> JSONArray(value.toList())
+      is FloatArray -> JSONArray(value.toList())
+      is BooleanArray -> JSONArray(value.toList())
+
+      else -> value.toString()
+    }
+  }
+}

package/android/src/main/java/io/hyperswitch/utils/StandardResult.kt

@@ -0,0 +1,45 @@
+package io.hyperswitch.utils
+
+import org.json.JSONObject
+sealed class StandardResult {
+
+  abstract val code: String?
+  abstract val message: String?
+  abstract val status: String
+  abstract val error: Throwable?
+
+  data class Success(
+    override val code: String? = null,
+    override val message: String? = null
+  ) : StandardResult() {
+    override val status: String = "success"
+    override val error: Throwable? = null
+  }
+
+  data class Failed(
+    override val code: String? = null,
+    override val message: String? = null,
+    override val error: Throwable? = null
+  ) : StandardResult() {
+    override val status: String = "failed"
+  }
+
+  data class Cancelled(
+    override val code: String? = null,
+    override val message: String? = "Payment cancelled"
+  ) : StandardResult() {
+    override val status: String = "cancelled"
+    override val error: Throwable? = null
+  }
+
+  fun toJSON(): JSONObject {
+    return JSONObject().apply {
+      put("code", code ?: JSONObject.NULL)
+      put("message", message ?: error?.message ?: JSONObject.NULL)
+      put("status", status)
+      put("error", error?.message ?: JSONObject.NULL)
+    }
+  }
+
+  fun toJSONString(): String = toJSON().toString()
+}

package/android/src/main/java/io/hyperswitch/view/GooglePayButtonView.kt

@@ -0,0 +1,59 @@
+package io.hyperswitch.view
+
+import android.util.Log
+import android.view.View
+import android.widget.FrameLayout
+import com.facebook.react.uimanager.PixelUtil
+import com.facebook.react.uimanager.ThemedReactContext
+import com.google.android.gms.wallet.button.ButtonConstants
+import com.google.android.gms.wallet.button.ButtonOptions
+import com.google.android.gms.wallet.button.PayButton
+
+class GooglePayButtonView(private val context: ThemedReactContext) : FrameLayout(context) {
+    
+    lateinit var allowedPaymentMethods: String
+    var type = ButtonConstants.ButtonType.PLAIN
+    var theme = ButtonConstants.ButtonTheme.DARK
+    var cornerRadius = 10
+    private var button: PayButton? = null
+
+    fun addButton() {
+        if (button != null) {
+            removeView(button)
+        }
+        button = initializeGooglePayButton()
+        addView(button)
+        viewTreeObserver.addOnGlobalLayoutListener { requestLayout() }
+    }
+
+    private fun initializeGooglePayButton(): PayButton {
+        val googlePayButton = PayButton(context)
+
+        val options = ButtonOptions.newBuilder()
+            .setAllowedPaymentMethods(allowedPaymentMethods)
+            .setButtonType(type)
+            .setButtonTheme(theme)
+            .setCornerRadius(PixelUtil.toPixelFromDIP(this.cornerRadius.toDouble()).toInt())
+        googlePayButton.initialize(options.build())
+        googlePayButton.setOnClickListener { _ ->
+            // Call the Javascript TouchableOpacity parent where the onClick handler is set
+            (this.parent as? View)?.performClick() ?: run {
+                Log.e("GooglePayReactNative", "Unable to find parent of GooglePayButtonView.")
+            }
+        }
+        return googlePayButton
+    }
+
+    override fun requestLayout() {
+        super.requestLayout()
+        post(mLayoutRunnable)
+    }
+
+    private val mLayoutRunnable = Runnable {
+        measure(
+            MeasureSpec.makeMeasureSpec(width, MeasureSpec.EXACTLY),
+            MeasureSpec.makeMeasureSpec(height, MeasureSpec.EXACTLY)
+        )
+        layout(left, top, right, bottom)
+    }
+}