@yuno-payments/yuno-sdk-react-native 1.0.16

package/android/src/main/java/com/yunosdkreactnative/YunoSdkModule.kt

@@ -0,0 +1,777 @@
+package com.yunosdkreactnative
+
+import android.app.Activity
+import android.content.Context
+import androidx.activity.ComponentActivity
+import com.facebook.react.bridge.*
+import com.facebook.react.modules.core.DeviceEventManagerModule
+import com.yuno.sdk.Yuno
+import com.yuno.sdk.YunoConfig
+import com.yuno.sdk.YunoLanguage
+import com.yuno.sdk.enrollment.*
+import com.yuno.sdk.payments.*
+import com.yuno.presentation.core.components.PaymentSelected
+import com.yuno.presentation.core.card.CardFormType
+import com.yuno.payments.features.payment.models.OneTimeTokenModel
+import com.google.gson.Gson
+import org.json.JSONObject
+import org.json.JSONArray
+
+/**
+ * Yuno SDK React Native Module for Android
+ * 
+ * This module bridges the Yuno native Android SDK to React Native,
+ * providing payment and enrollment functionalities.
+ * 
+ * IMPORTANT: Your MainActivity MUST call YunoSdkModule.registerYunoCallbacks(this)
+ * in onCreate() to register the required ActivityResultLaunchers.
+ */
+class YunoSdkModule(private val reactContext: ReactApplicationContext) :
+    ReactContextBaseJavaModule(reactContext), LifecycleEventListener {
+
+    private var isInitialized = false
+
+    companion object {
+        const val NAME = "YunoSdk"
+        private const val TAG = "YunoSdk"
+        
+        // Singleton instance
+        @Volatile
+        private var instance: YunoSdkModule? = null
+        
+        // Track if SDK was initialized by Activity before module loaded
+        @Volatile
+        private var sdkInitializedByActivity = false
+        
+        // Store the last OTT token received
+        @Volatile
+        private var lastOneTimeToken: String? = null
+        
+        // Store the last OTT token info received (full model)
+        @Volatile
+        private var lastOneTimeTokenInfo: OneTimeTokenModel? = null
+        
+        // Gson instance for JSON serialization
+        private val gson = Gson()
+        
+        /**
+         * Clear the last OTT tokens (token and tokenInfo).
+         * This should be called at the start of each new payment/enrollment flow
+         * to prevent contamination from previous flows.
+         */
+        @JvmStatic
+        fun clearLastOTT() {
+            lastOneTimeToken = null
+            lastOneTimeTokenInfo = null
+        }
+        
+        fun getInstance(): YunoSdkModule? = instance
+        
+        /**
+         * Initialize Yuno SDK with API key, application context and configuration.
+         * 
+         * IMPORTANT: This should be called from MainActivity to ensure
+         * the SDK is initialized with the application context (not activity context).
+         * 
+         * @param applicationContext The application context
+         * @param apiKey The Yuno API key
+         * @param language Optional language code (e.g., "pt-BR", "es", "en")
+         * @param cardType Card flow type ("ONE_STEP" or "STEP_BY_STEP")
+         * @param savedCardEnable Whether to enable saved card functionality
+         */
+        @JvmStatic
+        fun initialize(
+            applicationContext: android.content.Context,
+            apiKey: String,
+            language: String? = null,
+            cardType: String = "ONE_STEP",
+            savedCardEnable: Boolean = false
+        ) {
+            try {
+                // Map cardType string to CardFormType enum
+                val cardFormType = when (cardType.uppercase()) {
+                    "TWO_STEPS", "STEP_BY_STEP" -> CardFormType.STEP_BY_STEP
+                    else -> CardFormType.ONE_STEP
+                }
+                
+                // Map language string to YunoLanguage enum (if provided)
+                val yunoLanguage = language?.let {
+                    try {
+                        when {
+                            it.startsWith("en", ignoreCase = true) -> YunoLanguage.ENGLISH
+                            it.startsWith("es", ignoreCase = true) -> YunoLanguage.SPANISH
+                            it.startsWith("pt", ignoreCase = true) -> YunoLanguage.PORTUGUESE
+                            it.startsWith("id", ignoreCase = true) -> YunoLanguage.INDONESIAN
+                            it.startsWith("ms", ignoreCase = true) || it.startsWith("my", ignoreCase = true) -> YunoLanguage.MALAYSIAN
+                            it.startsWith("fr", ignoreCase = true) -> YunoLanguage.FRENCH
+                            it.startsWith("pl", ignoreCase = true) -> YunoLanguage.POLISH
+                            it.startsWith("it", ignoreCase = true) -> YunoLanguage.ITALIAN
+                            it.startsWith("de", ignoreCase = true) -> YunoLanguage.GERMAN
+                            it.startsWith("ru", ignoreCase = true) -> YunoLanguage.RUSSIAN
+                            it.startsWith("tr", ignoreCase = true) -> YunoLanguage.TURKISH
+                            it.startsWith("nl", ignoreCase = true) -> YunoLanguage.DUTCH
+                            it.startsWith("sv", ignoreCase = true) -> YunoLanguage.SWEDISH
+                            it.startsWith("th", ignoreCase = true) -> YunoLanguage.THAI
+                            it.startsWith("fil", ignoreCase = true) -> YunoLanguage.FILIPINO
+                            it.startsWith("vi", ignoreCase = true) -> YunoLanguage.VIETNAMESE
+                            it.startsWith("zh-cn", ignoreCase = true) -> YunoLanguage.CHINESE_SIMPLIFIED
+                            it.startsWith("zh-tw", ignoreCase = true) -> YunoLanguage.CHINESE_TRADITIONAL
+                            else -> null
+                        }
+                    } catch (e: Exception) {
+                        null
+                    }
+                }
+                
+                // Create YunoConfig
+                val config = YunoConfig(
+                    cardFlow = cardFormType,
+                    saveCardEnabled = savedCardEnable,
+                    language = yunoLanguage
+                )
+                
+                
+                // Initialize with config
+                Yuno.initialize(
+                    applicationContext = applicationContext,
+                    apiKey = apiKey,
+                    config = config
+                )
+                
+                // Mark that SDK was initialized by Activity
+                sdkInitializedByActivity = true
+                
+                // Also mark instance if it's already loaded
+                instance?.let { 
+                    it.isInitialized = true
+                }
+            } catch (e: Exception) {
+                throw e
+            }
+        }
+        
+        /**
+         * Register Yuno SDK callbacks for an activity.
+         * 
+         * IMPORTANT: This MUST be called from YunoActivity.onCreate() BEFORE super.onCreate()
+         * This is required by Android's registerForActivityResult() API.
+         * 
+         * The SDK must be already initialized before calling this method.
+         * 
+         * NOTE: This method can be called multiple times (e.g. when "Don't Keep Activities" is enabled
+         * and the activity is recreated). Android handles multiple registrations correctly by replacing
+         * the previous launcher.
+         * 
+         * @param activity The ComponentActivity instance (usually YunoActivity)
+         */
+        @JvmStatic
+        fun registerYunoCallbacks(activity: ComponentActivity) {
+            try {
+                
+                // Register payment callbacks
+                // Note: Android allows registering multiple times - the last registration wins
+                activity.startCheckout(
+                    callbackOTT = { token ->
+                        notifyOneTimeToken(token)
+                    },
+                    callbackPaymentState = { state ->
+                        notifyPaymentState(state)
+                    }
+                )
+
+                // Register enrollment callbacks
+                activity.initEnrollment { enrollmentState ->
+                    notifyEnrollmentState(enrollmentState)
+                }
+
+                
+            } catch (e: Exception) {
+                throw e
+            }
+        }
+        
+        @JvmStatic
+        fun notifyOneTimeToken(token: String?) {
+            
+            // ALWAYS store the token, even if React Native is not ready
+            lastOneTimeToken = token
+            
+            if (instance == null) {
+            } else {
+                instance?.sendOneTimeTokenEvent(token)
+            }
+        }
+        
+        @JvmStatic
+        fun notifyPaymentState(state: String?) {
+            if (instance == null) {
+            } else {
+                instance?.sendPaymentStatusEvent(state)
+            }
+        }
+        
+        @JvmStatic
+        fun notifyEnrollmentState(state: String?) {
+            if (instance == null) {
+            } else {
+                instance?.sendEnrollmentStatusEvent(state)
+            }
+        }
+    }
+
+    init {
+        reactContext.addLifecycleEventListener(this)
+        instance = this
+        
+        
+        // Check if SDK was already initialized by Activity before module loaded
+        if (sdkInitializedByActivity) {
+            this.isInitialized = true
+        } else {
+        }
+    }
+
+    override fun getName(): String = NAME
+
+    /**
+     * Initialize the Yuno SDK with configuration.
+     * 
+     * Note: If the SDK was already initialized in MainActivity.onCreate() via 
+     * registerYunoCallbacks(), this will be a no-op.
+     */
+    /**
+     * Initialize the Yuno SDK from JavaScript/React Native.
+     * This method extracts configuration from the provided maps and calls
+     * the static initialize() method from the companion object.
+     */
+    @ReactMethod
+    fun initialize(
+        apiKey: String,
+        countryCode: String,
+        config: ReadableMap,
+        iosConfig: ReadableMap,
+        androidConfig: ReadableMap,
+        promise: Promise
+    ) {
+        try {
+            if (this.isInitialized) {
+                promise.resolve(true)
+                return
+            }
+            
+            if (apiKey.isEmpty()) {
+                promise.reject("INVALID_API_KEY", "API key cannot be empty")
+                return
+            }
+
+            // Extract configuration from config map
+            val language = if (config.hasKey("language")) config.getString("language") else null
+            val cardType = if (config.hasKey("cardType")) config.getString("cardType") else null
+            val savedCardEnable = if (config.hasKey("saveCardEnabled")) config.getBoolean("saveCardEnabled") else false
+            
+            
+            // Call the static initialize method
+            initialize(
+                applicationContext = reactContext.applicationContext,
+                apiKey = apiKey,
+                language = language,
+                cardType = cardType ?: "ONE_STEP",
+                savedCardEnable = savedCardEnable
+            )
+            
+            this.isInitialized = true
+            promise.resolve(true)
+            
+        } catch (e: Exception) {
+            promise.reject("YUNO_SDK_ERROR", "Error initializing Yuno SDK: ${e.message}", e)
+        }
+    }
+
+    /**
+     * Start enrollment payment flow.
+     */
+    @ReactMethod
+    fun enrollmentPayment(params: ReadableMap, promise: Promise) {
+        if (!checkInitialized(promise)) return
+        clearLastOTT() // 🧹 Clear any previous OTT tokens before starting new flow
+
+        try {
+            val customerSession = params.getString("customerSession") ?: run {
+                promise.reject("INVALID_PARAMS", "customerSession is required")
+                return
+            }
+
+            val countryCode = params.getString("countryCode") ?: run {
+                promise.reject("INVALID_PARAMS", "countryCode is required")
+                return
+            }
+
+            val showEnrollmentStatus = if (params.hasKey("showEnrollmentStatus")) {
+                params.getBoolean("showEnrollmentStatus")
+            } else {
+                true
+            }
+
+            val activity = currentActivity ?: run {
+                promise.reject("NO_ACTIVITY", "Current activity is not available")
+                return
+            }
+
+            
+            // Start enrollment
+            activity.startEnrollment(
+                customerSession = customerSession,
+                countryCode = countryCode,
+                showEnrollmentStatus = showEnrollmentStatus,
+                callbackEnrollmentState = { enrollmentState ->
+                    sendEnrollmentStatusEvent(enrollmentState)
+                }
+            )
+
+            promise.resolve(true)
+            
+        } catch (e: Exception) {
+            promise.reject("ENROLLMENT_ERROR", "Error starting enrollment: ${e.message}", e)
+        }
+    }
+
+    /**
+     * Start payment lite flow.
+     */
+    @ReactMethod
+    fun startPaymentLite(params: ReadableMap, countryCode: String, promise: Promise) {
+        if (!checkInitialized(promise)) return
+        clearLastOTT() // 🧹 Clear any previous OTT tokens before starting new flow
+
+        try {
+            val checkoutSession = params.getString("checkoutSession") ?: run {
+                promise.reject("INVALID_PARAMS", "checkoutSession is required")
+                return
+            }
+
+            val showPaymentStatus = if (params.hasKey("showPaymentStatus")) {
+                params.getBoolean("showPaymentStatus")
+            } else {
+                true
+            }
+            
+            val methodSelected = params.getMap("methodSelected")
+            val vaultedToken = methodSelected?.getString("vaultedToken")
+            val paymentMethodType = methodSelected?.getString("paymentMethodType") ?: run {
+                promise.reject("INVALID_PARAMS", "paymentMethodType is required")
+                return
+            }
+
+            val activity = currentActivity ?: run {
+                promise.reject("NO_ACTIVITY", "Current activity is not available")
+                return
+            }
+
+
+            // Update checkout session
+            activity.updateCheckoutSession(
+                checkoutSession = checkoutSession,
+                countryCode = countryCode
+            )
+
+            // Start payment lite
+            activity.startPaymentLite(
+                paymentSelected = PaymentSelected(
+                    paymentMethodType = paymentMethodType,
+                    vaultedToken = vaultedToken
+                ),
+                showPaymentStatus = showPaymentStatus,
+                callbackOTT = { token ->
+                    notifyOneTimeToken(token)
+                },
+                callBackTokenWithInformation = { tokenModel ->
+                    // Send simple OTT event
+                    tokenModel?.token?.let { notifyOneTimeToken(it) }
+                    // Send full OTT info event with card and customer data
+                    sendOneTimeTokenInfoEvent(tokenModel)
+                }
+            )
+
+            promise.resolve(true)
+            
+        } catch (e: Exception) {
+            promise.reject("PAYMENT_LITE_ERROR", "Error starting payment lite: ${e.message}", e)
+        }
+    }
+
+    /**
+     * Start full payment flow.
+     */
+    @ReactMethod
+    fun startPayment(showPaymentStatus: Boolean, promise: Promise) {
+        if (!checkInitialized(promise)) return
+        clearLastOTT() // 🧹 Clear any previous OTT tokens before starting new flow
+
+        try {
+            val activity = currentActivity ?: run {
+                promise.reject("NO_ACTIVITY", "Current activity is not available")
+                return
+            }
+
+
+            // Start payment
+            activity.startPayment(
+                showPaymentStatus = showPaymentStatus,
+                callbackOTT = { token ->
+                    notifyOneTimeToken(token)
+                },
+                callBackTokenWithInformation = { tokenModel ->
+                    // Send simple OTT event
+                    tokenModel?.token?.let { notifyOneTimeToken(it) }
+                    // Send full OTT info event with card and customer data
+                    sendOneTimeTokenInfoEvent(tokenModel)
+                }
+            )
+            
+            promise.resolve(true)
+            
+        } catch (e: Exception) {
+            promise.reject("START_PAYMENT_ERROR", "Error starting payment: ${e.message}", e)
+        }
+    }
+
+    /**
+     * Continue a previously started payment.
+     */
+    @ReactMethod
+    fun continuePayment(checkoutSession: String, countryCode: String, showPaymentStatus: Boolean, promise: Promise) {
+        if (!checkInitialized(promise)) return
+
+        try {
+            val activity = currentActivity ?: run {
+                promise.reject("NO_ACTIVITY", "Current activity is not available")
+                return
+            }
+
+
+            // Continue payment
+            activity.continuePayment(
+                showPaymentStatus = showPaymentStatus,
+                checkoutSession = checkoutSession,
+                countryCode = countryCode,
+                callbackPaymentState = { paymentState ->
+                    sendPaymentStatusEvent(paymentState)
+                }
+            )
+            
+            promise.resolve(true)
+            
+        } catch (e: Exception) {
+            promise.reject("CONTINUE_PAYMENT_ERROR", "Error continuing payment: ${e.message}", e)
+        }
+    }
+
+    /**
+     * Hide the payment loader.
+     */
+    @ReactMethod
+    fun hideLoader(promise: Promise) {
+        if (!checkInitialized(promise)) return
+
+        try {
+            promise.resolve(true)
+        } catch (e: Exception) {
+            promise.reject("HIDE_LOADER_ERROR", "Error hiding loader: ${e.message}", e)
+        }
+    }
+
+    /**
+     * Handle deep link
+     */
+    @ReactMethod
+    fun receiveDeeplink(url: String, promise: Promise) {
+        promise.resolve(true)
+    }
+
+    /**
+     * Start seamless payment lite flow.
+     */
+    @ReactMethod
+    fun startPaymentSeamlessLite(params: ReadableMap, language: String, promise: Promise) {
+        if (!checkInitialized(promise)) return
+        clearLastOTT() // 🧹 Clear any previous OTT tokens before starting new flow
+
+        try {
+            val checkoutSession = params.getString("checkoutSession") ?: run {
+                promise.reject("INVALID_PARAMS", "checkoutSession is required")
+                return
+            }
+
+            val countryCode = params.getString("countryCode") ?: run {
+                promise.reject("INVALID_PARAMS", "countryCode is required")
+                return
+            }
+
+            val showPaymentStatus = if (params.hasKey("showPaymentStatus")) {
+                params.getBoolean("showPaymentStatus")
+            } else {
+                true
+            }
+            
+            val methodSelected = params.getMap("methodSelected")
+            val vaultedToken = methodSelected?.getString("vaultedToken")
+            val paymentMethodType = methodSelected?.getString("paymentMethodType") ?: run {
+                promise.reject("INVALID_PARAMS", "paymentMethodType is required")
+                return
+            }
+
+            val activity = currentActivity ?: run {
+                promise.reject("NO_ACTIVITY", "Current activity is not available")
+                return
+            }
+
+
+            // Update checkout session
+            activity.updateCheckoutSession(
+                checkoutSession = checkoutSession,
+                countryCode = countryCode
+            )
+
+            // Start seamless payment lite
+            activity.startPaymentSeamlessLite(
+                paymentSelected = PaymentSelected(
+                    paymentMethodType = paymentMethodType,
+                    vaultedToken = vaultedToken
+                ),
+                showPaymentStatus = showPaymentStatus,
+                callbackPaymentState = { paymentState ->
+                    sendPaymentStatusEvent(paymentState)
+                    promise.resolve(paymentState ?: "UNKNOWN")
+                }
+            )
+            
+        } catch (e: Exception) {
+            promise.reject("SEAMLESS_ERROR", "Error starting seamless payment: ${e.message}", e)
+        }
+    }
+
+    @ReactMethod
+    fun addListener(eventName: String) {
+        // Required for RN built-in EventEmitter Calls
+    }
+
+    @ReactMethod
+    fun removeListeners(count: Int) {
+        // Required for RN built-in EventEmitter Calls
+    }
+
+    /**
+     * Get the last One Time Token that was generated.
+     * This is useful when the OTT event was emitted while React Native was paused.
+     * 
+     * @param promise Promise that resolves with the last OTT token or null
+     */
+    @ReactMethod
+    fun getLastOneTimeToken(promise: Promise) {
+        try {
+            promise.resolve(lastOneTimeToken)
+        } catch (e: Exception) {
+            promise.reject("GET_OTT_ERROR", "Error getting last OTT: ${e.message}", e)
+        }
+    }
+
+    @ReactMethod
+    fun getLastOneTimeTokenInfo(promise: Promise) {
+        try {
+            val tokenInfo = lastOneTimeTokenInfo
+            
+            if (tokenInfo != null) {
+                // Convert to JSON string first
+                val jsonString = gson.toJson(tokenInfo)
+                
+                // Use existing conversion method
+                val params = convertJsonToMap(jsonString)
+                
+                promise.resolve(params)
+            } else {
+                promise.resolve(null)
+            }
+        } catch (e: Exception) {
+            promise.reject("GET_LAST_TOKEN_INFO_ERROR", e.message, e)
+        }
+    }
+
+    /**
+     * Clear the last OTT tokens manually from JavaScript.
+     * This is useful to ensure clean state before starting a new payment flow.
+     * 
+     * @param promise Promise that resolves to true when cleared
+     */
+    @ReactMethod
+    fun clearLastOneTimeToken(promise: Promise) {
+        try {
+            clearLastOTT()
+            promise.resolve(true)
+        } catch (e: Exception) {
+            promise.reject("CLEAR_OTT_ERROR", "Error clearing last OTT: ${e.message}", e)
+        }
+    }
+
+    // Lifecycle Methods
+    override fun onHostResume() {}
+    override fun onHostPause() {}
+    override fun onHostDestroy() {}
+
+    // Helper Methods
+    private fun checkInitialized(promise: Promise): Boolean {
+        
+        // Check if SDK was initialized by Activity
+        if (sdkInitializedByActivity && !isInitialized) {
+            isInitialized = true
+        }
+        
+        if (!isInitialized && !sdkInitializedByActivity) {
+            promise.reject("NOT_INITIALIZED", "Yuno SDK is not initialized. Call initialize() first.")
+            return false
+        }
+        
+        return true
+    }
+
+    private fun sendEvent(eventName: String, params: Any?) {
+        try {
+            reactContext
+                .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+                .emit(eventName, params)
+        } catch (e: Exception) {
+        }
+    }
+
+    internal fun sendOneTimeTokenEvent(token: String?) {
+        token?.let {
+            sendEvent("YunoOneTimeToken", it)
+        } ?: run {
+        }
+    }
+
+    internal fun sendPaymentStatusEvent(status: String?) {
+        val convertedStatus = convertPaymentStatus(status)
+        val params = Arguments.createMap().apply {
+            putString("status", convertedStatus)
+        }
+        sendEvent("YunoPaymentStatus", params)
+    }
+
+    internal fun sendEnrollmentStatusEvent(status: String?) {
+        val convertedStatus = convertEnrollmentStatus(status)
+        val params = Arguments.createMap().apply {
+            putString("status", convertedStatus)
+        }
+        sendEvent("YunoEnrollmentStatus", params)
+    }
+
+    private fun convertPaymentStatus(status: String?): String {
+        return when (status) {
+            PAYMENT_STATE_SUCCEEDED -> "SUCCEEDED"
+            PAYMENT_STATE_FAIL -> "FAILED"
+            PAYMENT_STATE_REJECT -> "REJECTED"
+            PAYMENT_STATE_STATE_CANCELED_BY_USER -> "CANCELLED"
+            PAYMENT_STATE_PROCESSING -> "PENDING"
+            PAYMENT_STATE_INTERNAL_ERROR -> "ERROR"
+            else -> "UNKNOWN"
+        }
+    }
+
+    private fun convertEnrollmentStatus(status: String?): String {
+        return when (status) {
+            ENROLLMENT_STATE_SUCCEEDED -> "SUCCEEDED"
+            ENROLLMENT_STATE_FAIL -> "FAILED"
+            ENROLLMENT_STATE_REJECT -> "REJECTED"
+            ENROLLMENT_STATE_CANCELED_BY_USER -> "CANCELLED"
+            ENROLLMENT_STATE_PROCESSING -> "PENDING"
+            ENROLLMENT_STATE_INTERNAL_ERROR -> "ERROR"
+            else -> "UNKNOWN"
+        }
+    }
+
+    /**
+     * Sends OneTimeTokenInfo event with full information including card and customer data.
+     * Uses Gson to convert the tokenModel to JSON and then to WritableMap.
+     */
+    internal fun sendOneTimeTokenInfoEvent(tokenModel: OneTimeTokenModel?) {
+        tokenModel?.let {
+            try {
+                
+                // Store the token info in companion object for later retrieval
+                lastOneTimeTokenInfo = it
+                
+                // Convert tokenModel to JSON using Gson
+                val gson = Gson()
+                val jsonString = gson.toJson(it)
+                
+                // Convert JSON to WritableMap
+                val tokenMap = convertJsonToMap(jsonString)
+                sendEvent("YunoOneTimeTokenInfo", tokenMap)
+            } catch (e: Exception) {
+            }
+        } ?: run {
+        }
+    }
+
+    /**
+     * Converts a JSON string to WritableMap for React Native.
+     */
+    private fun convertJsonToMap(jsonString: String): WritableMap {
+        val map = Arguments.createMap()
+        try {
+            val jsonObject = org.json.JSONObject(jsonString)
+            val keys = jsonObject.keys()
+            while (keys.hasNext()) {
+                val key = keys.next()
+                val value = jsonObject.get(key)
+                when (value) {
+                    is String -> map.putString(key, value)
+                    is Int -> map.putInt(key, value)
+                    is Double -> map.putDouble(key, value)
+                    is Boolean -> map.putBoolean(key, value)
+                    is org.json.JSONObject -> map.putMap(key, convertJsonObjectToMap(value))
+                    is org.json.JSONArray -> map.putArray(key, convertJsonArrayToArray(value))
+                    org.json.JSONObject.NULL -> map.putNull(key)
+                }
+            }
+        } catch (e: Exception) {
+        }
+        return map
+    }
+
+    private fun convertJsonObjectToMap(jsonObject: org.json.JSONObject): WritableMap {
+        val map = Arguments.createMap()
+        val keys = jsonObject.keys()
+        while (keys.hasNext()) {
+            val key = keys.next()
+            val value = jsonObject.get(key)
+            when (value) {
+                is String -> map.putString(key, value)
+                is Int -> map.putInt(key, value)
+                is Double -> map.putDouble(key, value)
+                is Boolean -> map.putBoolean(key, value)
+                is org.json.JSONObject -> map.putMap(key, convertJsonObjectToMap(value))
+                is org.json.JSONArray -> map.putArray(key, convertJsonArrayToArray(value))
+                org.json.JSONObject.NULL -> map.putNull(key)
+            }
+        }
+        return map
+    }
+
+    private fun convertJsonArrayToArray(jsonArray: org.json.JSONArray): WritableArray {
+        val array = Arguments.createArray()
+        for (i in 0 until jsonArray.length()) {
+            val value = jsonArray.get(i)
+            when (value) {
+                is String -> array.pushString(value)
+                is Int -> array.pushInt(value)
+                is Double -> array.pushDouble(value)
+                is Boolean -> array.pushBoolean(value)
+                is org.json.JSONObject -> array.pushMap(convertJsonObjectToMap(value))
+                is org.json.JSONArray -> array.pushArray(convertJsonArrayToArray(value))
+                org.json.JSONObject.NULL -> array.pushNull()
+            }
+        }
+        return array
+    }
+}