nimbbl-mobile-react-native-sdk 1.1.1 → 1.3.0

package/android/src/main/java/com/nimbbl/reactnative/NimbblReactNativeSDKModule.kt

@@ -2,63 +2,139 @@ package com.nimbbl.reactnative
 
 import android.app.Activity
 import android.content.Intent
-import android.util.Log
 import com.facebook.react.bridge.*
-import com.facebook.react.modules.core.DeviceEventManagerModule
 import tech.nimbbl.webviewsdk.core.NimbblCheckoutSDK
-import tech.nimbbl.webviewsdk.core.NimbblOrderCreation
+import tech.nimbbl.webviewsdk.core.NimbblShopOrderCreation
 import tech.nimbbl.webviewsdk.models.NimbblCheckoutOptions
 import tech.nimbbl.webviewsdk.models.interfaces.NimbblCheckoutPaymentListener
 import kotlinx.coroutines.*
 import retrofit2.Response
+import java.io.Serializable
+import org.json.JSONObject
+import org.json.JSONException
 
 class NimbblReactNativeSDKModule(private val reactContext: ReactApplicationContext) : 
     ReactContextBaseJavaModule(reactContext), ActivityEventListener {
     
     companion object {
-        private const val TAG = "NimbblReactNativeSDK"
+        private var instance: NimbblReactNativeSDKModule? = null
+        
+        fun handleCheckoutResponse(data: MutableMap<String, Any>) {
+            
+            try {
+                instance?.let { module ->
+                // Convert Map to WritableMap
+                val responseData = Arguments.createMap().apply {
+                    data.forEach { (key, value) ->
+                        when (value) {
+                            is String -> {
+                                // Special handling for 'order' field - parse JSON string to object
+                                if (key == "order" && value.startsWith("{") && value.endsWith("}")) {
+                                    try {
+                                        val jsonObject = JSONObject(value)
+                                        val orderMap = Arguments.createMap()
+                                        
+                                        // Convert JSONObject to WritableMap
+                                        jsonObject.keys().forEach { jsonKey ->
+                                            val jsonValue = jsonObject.get(jsonKey)
+                                            when (jsonValue) {
+                                                is String -> orderMap.putString(jsonKey, jsonValue)
+                                                is Number -> orderMap.putDouble(jsonKey, jsonValue.toDouble())
+                                                is Boolean -> orderMap.putBoolean(jsonKey, jsonValue)
+                                                is JSONObject -> {
+                                                    val nestedMap = Arguments.createMap()
+                                                    jsonValue.keys().forEach { nestedKey ->
+                                                        val nestedValue = jsonValue.get(nestedKey)
+                                                        when (nestedValue) {
+                                                            is String -> nestedMap.putString(nestedKey, nestedValue)
+                                                            is Number -> nestedMap.putDouble(nestedKey, nestedValue.toDouble())
+                                                            is Boolean -> nestedMap.putBoolean(nestedKey, nestedValue)
+                                                            else -> nestedMap.putString(nestedKey, nestedValue.toString())
+                                                        }
+                                                    }
+                                                    orderMap.putMap(jsonKey, nestedMap)
+                                                }
+                                                else -> orderMap.putString(jsonKey, jsonValue.toString())
+                                            }
+                                        }
+                                        
+                                        putMap(key, orderMap)
+                                    } catch (e: JSONException) {
+                                        putString(key, value)
+                                    }
+                                } else {
+                                    putString(key, value)
+                                }
+                            }
+                            is Number -> putDouble(key, value.toDouble())
+                            is Boolean -> putBoolean(key, value)
+                            is Map<*, *> -> {
+                                val nestedMap = Arguments.createMap()
+                                (value as Map<String, Any>).forEach { (nestedKey, nestedValue) ->
+                                    when (nestedValue) {
+                                        is String -> nestedMap.putString(nestedKey, nestedValue)
+                                        is Number -> nestedMap.putDouble(nestedKey, nestedValue.toDouble())
+                                        is Boolean -> nestedMap.putBoolean(nestedKey, nestedValue)
+                                        else -> nestedMap.putString(nestedKey, nestedValue.toString())
+                                    }
+                                }
+                                putMap(key, nestedMap)
+                            }
+                            else -> putString(key, value.toString())
+                        }
+                    }
+                }
+                
+                // Use callback if available
+                if (module.checkoutCallback != null) {
+                    module.checkoutCallback?.invoke(responseData)
+                }
+                }
+            } catch (e: Exception) {
+                // Error in handleCheckoutResponse - ignore
+            }
+        }
     }
     
     private var config: MutableMap<String, Any> = mutableMapOf()
     private var isInitialized = false
+    private var checkoutCallback: ((WritableMap) -> Unit)? = null
     
     init {
         reactContext.addActivityEventListener(this)
+        instance = this
     }
     
     override fun getName(): String {
         return "NimbblReactNativeSDK"
     }
     
-    override fun getConstants(): MutableMap<String, Any> {
-        return mutableMapOf(
-            "SDK_VERSION" to "1.0.0",
-            "PLATFORM" to "android"
-        )
+
+    @ReactMethod
+    fun addListener(@Suppress("UNUSED_PARAMETER") eventName: String) {
+        // Required for NativeEventEmitter - no action needed
+    }
+
+    @ReactMethod
+    fun removeListeners(@Suppress("UNUSED_PARAMETER") count: Int) {
+        // Required for NativeEventEmitter - no action needed
     }
     
+
     @ReactMethod
-    fun testModule(promise: Promise) {
-        try {
-            println("NimbblReactNativeSDK testModule called")
-            Log.d(TAG, "testModule called - Android native module is working")
-            val result = Arguments.createMap().apply {
-                putString("status", "success")
-                putString("message", "Module is working")
+    fun setCheckoutCallback(callback: Callback) {
+        this.checkoutCallback = { result ->
+            try {
+                callback.invoke(result)
+            } catch (e: Exception) {
+                // Error calling React Native callback - ignore
             }
-            promise.resolve(result)
-        } catch (error: Exception) {
-            println("Error in testModule: ${error.message}")
-            Log.e(TAG, "Error in testModule: ${error.message}", error)
-            promise.reject("TEST_MODULE_FAILED", error.message, error)
         }
     }
 
     @ReactMethod
     fun initialize(config: ReadableMap, promise: Promise) {
         try {
-            Log.d(TAG, "Initializing Nimbbl SDK")
-            
             if (config == null) {
                 promise.reject("INVALID_CONFIG", "Configuration is required")
                 return
@@ -66,13 +142,14 @@ class NimbblReactNativeSDKModule(private val reactContext: ReactApplicationConte
 
             // Extract configuration
             this.config.clear()
-            this.config["environment"] = config.getString("environment") ?: "sandbox"
-            
-            config.getMap("options")?.let { options ->
-                this.config["timeout"] = if (options.hasKey("timeout")) options.getInt("timeout") else 30000
-                this.config["enable_logging"] = if (options.hasKey("enable_logging")) options.getBoolean("enable_logging") else true
-                this.config["enable_analytics"] = if (options.hasKey("enable_analytics")) options.getBoolean("enable_analytics") else true
-                this.config["api_base_url"] = if (options.hasKey("api_base_url")) options.getString("api_base_url") ?: "https://api.nimbbl.tech" else "https://api.nimbbl.tech"
+            this.config["api_base_url"] = config.getString("api_base_url") ?: "https://api.nimbbl.tech"
+
+            // Set environment URL on the native SDK during initialization
+            val apiBaseUrl = this.config["api_base_url"] as? String
+            if (!apiBaseUrl.isNullOrEmpty()) {
+                // Ensure URL ends with / to prevent URL construction issues
+                val normalizedUrl = if (apiBaseUrl.endsWith("/")) apiBaseUrl else apiBaseUrl + "/"
+                NimbblCheckoutSDK.getInstance().setEnvironmentUrl(normalizedUrl)
             }
 
             isInitialized = true
@@ -85,48 +162,28 @@ class NimbblReactNativeSDKModule(private val reactContext: ReactApplicationConte
             promise.resolve(result)
             
         } catch (e: Exception) {
-            Log.e(TAG, "Error initializing SDK", e)
             promise.reject("INITIALIZATION_FAILED", e.message)
         }
     }
 
     @ReactMethod
     fun createShopOrder(orderData: ReadableMap, promise: Promise) {
-        Log.d(TAG, "=== CREATE SHOP ORDER METHOD CALLED ===")
-        println("NimbblReactNativeSDK createShopOrder method called")
-        
         try {
             if (!isInitialized) {
-                Log.e(TAG, "SDK not initialized")
                 promise.reject("NOT_INITIALIZED", "SDK must be initialized before creating orders")
                 return
             }
-
-            Log.d(TAG, "Creating shop order: $orderData")
-            println("Creating shop order with data: $orderData")
             
             // Extract order data
             val currency = orderData.getString("currency") ?: "INR"
             val amountString = orderData.getString("amount") ?: "0"
             val amount = amountString.toDoubleOrNull() ?: 0.0
             val productId = orderData.getString("product_id") ?: "11"
-            val orderLineItems = orderData.getBoolean("orderLineItems")
-            val checkoutExperience = orderData.getString("checkout_experience") ?: "redirect"
             val paymentMode = orderData.getString("payment_mode") ?: ""
-            val subPaymentMode = orderData.getString("subPaymentMode") ?: ""
             
-            Log.d(TAG, "Extracted order data:")
-            Log.d(TAG, "  - currency: $currency")
-            Log.d(TAG, "  - amount: $amount")
-            Log.d(TAG, "  - productId: $productId")
-            Log.d(TAG, "  - orderLineItems: $orderLineItems")
-            Log.d(TAG, "  - checkoutExperience: $checkoutExperience")
-            Log.d(TAG, "  - paymentMode: $paymentMode")
-            Log.d(TAG, "  - subPaymentMode: $subPaymentMode")
             
             // Validate required fields
             if (amountString.isEmpty() || currency.isEmpty()) {
-                Log.e(TAG, "Amount or currency is empty")
                 promise.reject("INVALID_ORDER_DATA", "Amount and currency are required")
                 return
             }
@@ -139,55 +196,22 @@ class NimbblReactNativeSDKModule(private val reactContext: ReactApplicationConte
                 null
             }
             
-            Log.d(TAG, "User data: $user")
-            
             // Use the actual Nimbbl Android SDK to create order
             // Set environment URL if provided
             val apiBaseUrl = config["api_base_url"] as? String
             if (!apiBaseUrl.isNullOrEmpty()) {
-                Log.d(TAG, "Setting environment URL: $apiBaseUrl")
-                NimbblCheckoutSDK.instance?.setEnvironmentUrl(apiBaseUrl)
+                NimbblCheckoutSDK.getInstance().setEnvironmentUrl(apiBaseUrl)
             }
-            
+
             // Extract user details for order creation
             val userEmail = user?.get("email") as? String ?: ""
             val userName = user?.get("name") as? String ?: ""
             val userMobile = user?.get("mobile_number") as? String ?: ""
             
-            Log.d(TAG, "User details:")
-            Log.d(TAG, "  - email: $userEmail")
-            Log.d(TAG, "  - name: $userName")
-            Log.d(TAG, "  - mobile: $userMobile")
-            
-            Log.d(TAG, "About to attempt Android SDK call")
-            println("About to attempt Android SDK call")
-            
             // Try to use the actual Android SDK for order creation
             try {
-                Log.d(TAG, "Attempting to use Android SDK for order creation...")
-                println("Attempting to use Android SDK for order creation...")
-                
                 // Get the API base URL from config
-                val apiBaseUrl = config["api_base_url"] as? String ?: "https://api.nimbbl.tech/"
-                Log.d(TAG, "Using API base URL: $apiBaseUrl")
-                println("Using API base URL: $apiBaseUrl")
-                
-                Log.d(TAG, "Calling createOrder with parameters:")
-                Log.d(TAG, "  - apiBaseUrl: $apiBaseUrl")
-                Log.d(TAG, "  - amountString: $amountString")
-                Log.d(TAG, "  - userEmail: $userEmail")
-                Log.d(TAG, "  - userName: $userName")
-                Log.d(TAG, "  - userMobile: $userMobile")
-                Log.d(TAG, "  - productId: $productId")
-                Log.d(TAG, "  - paymentMode: $paymentMode")
-                println("Calling createOrder with parameters:")
-                println("  - apiBaseUrl: $apiBaseUrl")
-                println("  - amountString: $amountString")
-                println("  - userEmail: $userEmail")
-                println("  - userName: $userName")
-                println("  - userMobile: $userMobile")
-                println("  - productId: $productId")
-                println("  - paymentMode: $paymentMode")
+                val orderApiBaseUrl = config["api_base_url"] as? String ?: "https://api.nimbbl.tech/"
                 
                 // Use direct method call with coroutine (since createOrder is a suspend function)
                 // Convert amount string to int
@@ -195,8 +219,8 @@ class NimbblReactNativeSDKModule(private val reactContext: ReactApplicationConte
                 
                 // Use coroutine to call suspend function
                 val orderResult = runBlocking {
-                    NimbblOrderCreation.createOrder(
-                        apiBaseUrl,
+                    NimbblShopOrderCreation.createShopOrder(
+                        orderApiBaseUrl,
                         amountInt, // Use amount as int
                         userEmail,
                         userName,
@@ -207,90 +231,54 @@ class NimbblReactNativeSDKModule(private val reactContext: ReactApplicationConte
                     )
                 }
                 
-                Log.d(TAG, "Order creation result: $orderResult")
-                println("Order creation result: $orderResult")
-                
                 // The result should be a Response object
                 if (orderResult != null) {
-                    Log.d(TAG, "Order result is not null, checking if successful...")
-                    println("Order result is not null, checking if successful...")
-                    
                     // Check if the response is successful
                     if (orderResult.isSuccessful) {
-                        Log.d(TAG, "Response is successful, getting body...")
-                        println("Response is successful, getting body...")
-                        
                         // Get the response body
                         val responseBody = orderResult.body()
-                        
-                        Log.d(TAG, "Response body: $responseBody")
-                        println("Response body: $responseBody")
-                        
+
                         if (responseBody != null) {
-                            Log.d(TAG, "Response body is not null, extracting token...")
-                            println("Response body is not null, extracting token...")
-                            
                             // Extract token from response body
                             val token = responseBody.token
                             val orderId = responseBody.orderId
                             
-                            Log.d(TAG, "Extracted token: $token")
-                            Log.d(TAG, "Extracted order ID: $orderId")
-                            println("Extracted token: $token")
-                            println("Extracted order ID: $orderId")
-                            
                             if (!token.isNullOrEmpty()) {
                                 val result = Arguments.createMap().apply {
-                                    putString("order_id", orderId ?: "order_${System.currentTimeMillis()}")
+                                    putString("order_id", orderId)
                                     putString("token", token)
                                     putString("status", "created")
                                     putDouble("amount", amount)
                                     putString("currency", currency)
                                 }
-                                
-                                Log.d(TAG, "Order created successfully with real token: $result")
-                                println("Order created successfully with real token: $result")
+
                                 promise.resolve(result)
                                 return
                             } else {
-                                Log.e(TAG, "Token is null or empty in response")
-                                println("Token is null or empty in response")
                                 promise.reject("INVALID_RESPONSE", "Token is null or empty in response")
                                 return
                             }
                         } else {
-                            Log.e(TAG, "Response body is null")
-                            println("Response body is null")
                             promise.reject("INVALID_RESPONSE", "Response body is null")
                             return
                         }
                     } else {
                         // Get error body for logging
                         val errorBody = orderResult.errorBody()
-                        Log.e(TAG, "Order creation failed, error body: $errorBody")
-                        println("Order creation failed, error body: $errorBody")
                         promise.reject("ORDER_CREATION_FAILED", "Order creation failed: $errorBody")
                         return
                     }
                 } else {
-                    Log.e(TAG, "Order creation result is null")
-                    println("Order creation result is null")
                     promise.reject("ORDER_CREATION_FAILED", "Order creation result is null")
                     return
                 }
                 
             } catch (e: Exception) {
-                Log.e(TAG, "Android SDK order creation failed: ${e.message}", e)
-                println("Android SDK order creation failed: ${e.message}")
-                e.printStackTrace()
                 promise.reject("ORDER_CREATION_FAILED", "Android SDK order creation failed: ${e.message}")
                 return
             }
             
         } catch (e: Exception) {
-            Log.e(TAG, "Error creating shop order", e)
-            println("Error creating shop order: ${e.message}")
-            e.printStackTrace()
             promise.reject("ORDER_CREATION_FAILED", e.message)
         }
     }
@@ -299,16 +287,11 @@ class NimbblReactNativeSDKModule(private val reactContext: ReactApplicationConte
 
     @ReactMethod
     fun checkout(options: ReadableMap, promise: Promise) {
-        Log.d(TAG, "=== CHECKOUT METHOD CALLED ===")
-        println("NimbblReactNativeSDK checkout method called")
-        
         try {
             if (!isInitialized) {
                 promise.reject("NOT_INITIALIZED", "SDK must be initialized before checkout")
                 return
             }
-
-            Log.d(TAG, "Opening checkout with options: $options")
             
             val orderToken = options.getString("order_token")
             val paymentModeCode = options.getString("payment_mode_code") ?: ""
@@ -320,45 +303,107 @@ class NimbblReactNativeSDKModule(private val reactContext: ReactApplicationConte
                 promise.reject("INVALID_OPTIONS", "Order token is required")
                 return
             }
-
-            Log.d(TAG, "Building checkout options...")
             
             // Get the current Activity
             val currentActivity = reactContext.currentActivity
-            Log.d(TAG, "Current activity: $currentActivity")
             
             if (currentActivity == null) {
-                Log.e(TAG, "Current activity is null!")
                 promise.reject("ACTIVITY_ERROR", "Current activity is null")
                 return
             }
             
-            // Start the custom NimbblCheckoutActivity instead of trying to use MainActivity
-            Log.d(TAG, "Starting NimbblCheckoutActivity...")
-            println("Starting NimbblCheckoutActivity...")
+            // Use the NimbblCheckoutActivity with proper callback setup
             try {
-                Log.d(TAG, "Creating intent for NimbblCheckoutActivity...")
-                println("Creating intent for NimbblCheckoutActivity...")
-                
-                // Use startActivityForResult to properly handle callbacks
-                val intent = Intent(currentActivity, NimbblCheckoutActivity::class.java).apply {
-                    putExtra(NimbblCheckoutActivity.EXTRA_ORDER_TOKEN, orderToken)
-                    putExtra(NimbblCheckoutActivity.EXTRA_PAYMENT_MODE_CODE, paymentModeCode)
-                    putExtra(NimbblCheckoutActivity.EXTRA_BANK_CODE, bankCode)
-                    putExtra(NimbblCheckoutActivity.EXTRA_WALLET_CODE, walletCode)
-                    putExtra(NimbblCheckoutActivity.EXTRA_PAYMENT_FLOW, paymentFlow)
+                // Set up the callback to receive the result
+                NimbblCheckoutActivity.setResultCallback { result ->
+                    
+                    // Convert Map to WritableMap
+                    val responseData = Arguments.createMap().apply {
+                        result.forEach { (key, value) ->
+                            when (value) {
+                                is String -> {
+                                    // Special handling for 'order' field - parse JSON string to object
+                                    if (key == "order" && value.startsWith("{") && value.endsWith("}")) {
+                                        try {
+                                            val jsonObject = JSONObject(value)
+                                            val orderMap = Arguments.createMap()
+                                            
+                                            // Convert JSONObject to WritableMap
+                                            jsonObject.keys().forEach { jsonKey ->
+                                                val jsonValue = jsonObject.get(jsonKey)
+                                                when (jsonValue) {
+                                                    is String -> orderMap.putString(jsonKey, jsonValue)
+                                                    is Number -> orderMap.putDouble(jsonKey, jsonValue.toDouble())
+                                                    is Boolean -> orderMap.putBoolean(jsonKey, jsonValue)
+                                                    is JSONObject -> {
+                                                        val nestedMap = Arguments.createMap()
+                                                        jsonValue.keys().forEach { nestedKey ->
+                                                            val nestedValue = jsonValue.get(nestedKey)
+                                                            when (nestedValue) {
+                                                                is String -> nestedMap.putString(nestedKey, nestedValue)
+                                                                is Number -> nestedMap.putDouble(nestedKey, nestedValue.toDouble())
+                                                                is Boolean -> nestedMap.putBoolean(nestedKey, nestedValue)
+                                                                else -> nestedMap.putString(nestedKey, nestedValue.toString())
+                                                            }
+                                                        }
+                                                        orderMap.putMap(jsonKey, nestedMap)
+                                                    }
+                                                    else -> orderMap.putString(jsonKey, jsonValue.toString())
+                                                }
+                                            }
+                                            
+                                            putMap(key, orderMap)
+                                        } catch (e: JSONException) {
+                                            putString(key, value)
+                                        }
+                                    } else {
+                                        putString(key, value)
+                                    }
+                                }
+                                is Number -> putDouble(key, value.toDouble())
+                                is Boolean -> putBoolean(key, value)
+                                is Map<*, *> -> {
+                                    val nestedMap = Arguments.createMap()
+                                    (value as Map<String, Any>).forEach { (nestedKey, nestedValue) ->
+                                        when (nestedValue) {
+                                            is String -> nestedMap.putString(nestedKey, nestedValue)
+                                            is Number -> nestedMap.putDouble(nestedKey, nestedValue.toDouble())
+                                            is Boolean -> nestedMap.putBoolean(nestedKey, nestedValue)
+                                            else -> nestedMap.putString(nestedKey, nestedValue.toString())
+                                        }
+                                    }
+                                    putMap(key, nestedMap)
+                                }
+                                else -> putString(key, value.toString())
+                            }
+                        }
+                    }
+                    
+                    // Use callback if available
+                    if (checkoutCallback != null) {
+                        try {
+                            checkoutCallback?.invoke(responseData)
+                        } catch (e: Exception) {
+                            // Error invoking checkout callback - ignore
+                        }
+                    }
                 }
                 
-                // Use a request code to identify this activity result
-                val REQUEST_CHECKOUT = 1001
-                currentActivity.startActivityForResult(intent, REQUEST_CHECKOUT)
+                // Add a small delay to ensure callback is properly set up
+                android.os.Handler(android.os.Looper.getMainLooper()).postDelayed({
+                    // Start the NimbblCheckoutActivity
+                    val intent = Intent(currentActivity, NimbblCheckoutActivity::class.java).apply {
+                        putExtra(NimbblCheckoutActivity.EXTRA_ORDER_TOKEN, orderToken)
+                        putExtra(NimbblCheckoutActivity.EXTRA_PAYMENT_MODE_CODE, paymentModeCode)
+                        putExtra(NimbblCheckoutActivity.EXTRA_BANK_CODE, bankCode)
+                        putExtra(NimbblCheckoutActivity.EXTRA_WALLET_CODE, walletCode)
+                        putExtra(NimbblCheckoutActivity.EXTRA_PAYMENT_FLOW, paymentFlow)
+                    }
+                    
+                    currentActivity.startActivity(intent)
+                }, 50) // 50ms delay to ensure callback is set up
                 
-                Log.d(TAG, "NimbblCheckoutActivity started successfully")
-                println("NimbblCheckoutActivity started successfully")
             } catch (e: Exception) {
-                Log.e(TAG, "Error starting NimbblCheckoutActivity: ${e.message}", e)
-                println("Error starting NimbblCheckoutActivity: ${e.message}")
-                e.printStackTrace()
                 promise.reject("CHECKOUT_FAILED", "Error starting checkout activity: ${e.message}")
                 return
             }
@@ -370,52 +415,103 @@ class NimbblReactNativeSDKModule(private val reactContext: ReactApplicationConte
             promise.resolve(result)
             
         } catch (e: Exception) {
-            Log.e(TAG, "Error during checkout", e)
             promise.reject("CHECKOUT_FAILED", e.message)
         }
     }
 
 
-    private fun sendEvent(eventName: String, params: WritableMap?) {
-        try {
-            reactContext
-                .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
-                .emit(eventName, params)
-        } catch (e: Exception) {
-            Log.e(TAG, "Error sending event: $eventName", e)
-        }
-    }
 
     override fun onActivityResult(activity: Activity?, requestCode: Int, resultCode: Int, data: Intent?) {
+        
         // Handle NimbblCheckoutActivity results
-        if (requestCode == 1001 && data != null) {
-            val status = data.getStringExtra("status")
-            
-            when (status) {
-                "success" -> {
-                    val params = Arguments.createMap().apply {
-                        putString("status", "success")
-                        putString("order_id", data.getStringExtra("order_id") ?: "")
-                        putString("payment_id", data.getStringExtra("payment_id") ?: "")
-                        putString("data", data.getStringExtra("response") ?: "")
+        if (requestCode == 1001) {
+            val responseData = if (data != null) {
+                val rawData = data.getSerializableExtra("response_data") as? MutableMap<String, Any>
+                
+                if (rawData != null) {
+                    // Convert Map to WritableMap directly
+                    Arguments.createMap().apply {
+                        rawData.forEach { (key, value) ->
+                            when (value) {
+                                is String -> {
+                                    // Special handling for 'order' field - parse JSON string to object
+                                    if (key == "order" && value.startsWith("{") && value.endsWith("}")) {
+                                        try {
+                                            val jsonObject = JSONObject(value)
+                                            val orderMap = Arguments.createMap()
+                                            
+                                            // Convert JSONObject to WritableMap
+                                            jsonObject.keys().forEach { jsonKey ->
+                                                val jsonValue = jsonObject.get(jsonKey)
+                                                when (jsonValue) {
+                                                    is String -> orderMap.putString(jsonKey, jsonValue)
+                                                    is Number -> orderMap.putDouble(jsonKey, jsonValue.toDouble())
+                                                    is Boolean -> orderMap.putBoolean(jsonKey, jsonValue)
+                                                    is JSONObject -> {
+                                                        val nestedMap = Arguments.createMap()
+                                                        jsonValue.keys().forEach { nestedKey ->
+                                                            val nestedValue = jsonValue.get(nestedKey)
+                                                            when (nestedValue) {
+                                                                is String -> nestedMap.putString(nestedKey, nestedValue)
+                                                                is Number -> nestedMap.putDouble(nestedKey, nestedValue.toDouble())
+                                                                is Boolean -> nestedMap.putBoolean(nestedKey, nestedValue)
+                                                                else -> nestedMap.putString(nestedKey, nestedValue.toString())
+                                                            }
+                                                        }
+                                                        orderMap.putMap(jsonKey, nestedMap)
+                                                    }
+                                                    else -> orderMap.putString(jsonKey, jsonValue.toString())
+                                                }
+                                            }
+                                            
+                                            putMap(key, orderMap)
+                                        } catch (e: JSONException) {
+                                            putString(key, value)
+                                        }
+                                    } else {
+                                        putString(key, value)
+                                    }
+                                }
+                                is Number -> putDouble(key, value.toDouble())
+                                is Boolean -> putBoolean(key, value)
+                                is Map<*, *> -> {
+                                    val nestedMap = Arguments.createMap()
+                                    (value as Map<String, Any>).forEach { (nestedKey, nestedValue) ->
+                                        when (nestedValue) {
+                                            is String -> nestedMap.putString(nestedKey, nestedValue)
+                                            is Number -> nestedMap.putDouble(nestedKey, nestedValue.toDouble())
+                                            is Boolean -> nestedMap.putBoolean(nestedKey, nestedValue)
+                                            else -> nestedMap.putString(nestedKey, nestedValue.toString())
+                                        }
+                                    }
+                                    putMap(key, nestedMap)
+                                }
+                                else -> putString(key, value.toString())
+                            }
+                        }
                     }
-                    sendEvent("payment_success", params)
-                }
-                "failed" -> {
-                    val params = Arguments.createMap().apply {
+                } else {
+                    Arguments.createMap().apply {
                         putString("status", "failed")
-                        putString("data", data.getStringExtra("response") ?: "")
+                        putString("message", "No response data received")
                     }
-                    sendEvent("payment_failed", params)
                 }
-                "cancelled" -> {
-                    // Don't send cancelled event since back button is blocked
-                    // Only success and failure events should be sent to the sample app
+            } else {
+                Arguments.createMap().apply {
+                    putString("status", "failed")
+                    putString("message", "Payment was cancelled or failed")
                 }
             }
+            
+            // Use callback if available
+            if (checkoutCallback != null) {
+                checkoutCallback?.invoke(responseData)
+            }
+            // Note: Removed fallback to event emitter for cleaner implementation
         }
     }
 
+
     override fun onNewIntent(intent: Intent?) {
         // Handle new intents if needed
     }
@@ -424,5 +520,5 @@ class NimbblReactNativeSDKModule(private val reactContext: ReactApplicationConte
         super.onCatalystInstanceDestroy()
         reactContext.removeActivityEventListener(this)
     }
-    
+
 }