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

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

@@ -3,19 +3,97 @@ package com.nimbbl.reactnative
 import android.app.Activity
 import android.content.Intent
 import com.facebook.react.bridge.*
-import com.facebook.react.modules.core.DeviceEventManagerModule
 import tech.nimbbl.webviewsdk.core.NimbblCheckoutSDK
 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()
@@ -24,28 +102,24 @@ class NimbblReactNativeSDKModule(private val reactContext: ReactApplicationConte
     
     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 setCheckoutCallback(callback: Callback) {
@@ -53,7 +127,7 @@ class NimbblReactNativeSDKModule(private val reactContext: ReactApplicationConte
             try {
                 callback.invoke(result)
             } catch (e: Exception) {
-                // Error calling checkout callback, ignore
+                // Error calling React Native callback - ignore
             }
         }
     }
@@ -68,19 +142,14 @@ class NimbblReactNativeSDKModule(private val reactContext: ReactApplicationConte
 
             // Extract configuration
             this.config.clear()
-            this.config["environment"] = config.getString("environment") ?: "production"
-            
-            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 false
-                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()) {
-                NimbblCheckoutSDK.getInstance().setEnvironmentUrl(apiBaseUrl)
+                // Ensure URL ends with / to prevent URL construction issues
+                val normalizedUrl = if (apiBaseUrl.endsWith("/")) apiBaseUrl else apiBaseUrl + "/"
+                NimbblCheckoutSDK.getInstance().setEnvironmentUrl(normalizedUrl)
             }
 
             isInitialized = true
@@ -243,21 +312,96 @@ class NimbblReactNativeSDKModule(private val reactContext: ReactApplicationConte
                 return
             }
             
-            // Start the custom NimbblCheckoutActivity instead of trying to use MainActivity
+            // Use the NimbblCheckoutActivity with proper callback setup
             try {
-                
-                // 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
                 
             } catch (e: Exception) {
                 promise.reject("CHECKOUT_FAILED", "Error starting checkout activity: ${e.message}")
@@ -276,47 +420,98 @@ class NimbblReactNativeSDKModule(private val reactContext: ReactApplicationConte
     }
 
 
-    private fun sendEvent(eventName: String, params: WritableMap?) {
-        try {
-            reactContext
-                .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
-                .emit(eventName, params)
-        } catch (e: Exception) {
-            // Error sending event, ignore
-        }
-    }
 
     override fun onActivityResult(activity: Activity?, requestCode: Int, resultCode: Int, data: Intent?) {
+        
         // Handle NimbblCheckoutActivity results
         if (requestCode == 1001) {
             val responseData = if (data != null) {
-                val status = data.getStringExtra("status")
-
-                Arguments.createMap().apply {
-                    putString("status", status)
-                    putString("order_id", data.getStringExtra("order_id") ?: "")
-                    putString("payment_id", data.getStringExtra("payment_id") ?: "")
-                    putString("data", data.getStringExtra("response") ?: "")
+                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())
+                            }
+                        }
+                    }
+                } else {
+                    Arguments.createMap().apply {
+                        putString("status", "failed")
+                        putString("message", "No response data received")
+                    }
                 }
             } else {
                 Arguments.createMap().apply {
                     putString("status", "failed")
                     putString("message", "Payment was cancelled or failed")
-                    putString("order_id", "")
-                    putString("payment_id", "")
-                    putString("data", "")
                 }
             }
             
-            // Use callback if available, otherwise fall back to event
+            // Use callback if available
             if (checkoutCallback != null) {
                 checkoutCallback?.invoke(responseData)
-            } else {
-                sendEvent("checkout_response", responseData)
             }
+            // Note: Removed fallback to event emitter for cleaner implementation
         }
     }
 
+
     override fun onNewIntent(intent: Intent?) {
         // Handle new intents if needed
     }
@@ -325,5 +520,5 @@ class NimbblReactNativeSDKModule(private val reactContext: ReactApplicationConte
         super.onCatalystInstanceDestroy()
         reactContext.removeActivityEventListener(this)
     }
-    
+
 }

package/ios/NimbblReactNativeSDK.swift

@@ -8,7 +8,6 @@ class NimbblReactNativeSDK: RCTEventEmitter, NimbblCheckoutSDKDelegate {
     
     private var config: [String: Any] = [:]
     private var isInitialized = false
-    private var hasListeners = false
     private var checkoutCallback: RCTResponseSenderBlock?
     
     override init() {
@@ -16,30 +15,11 @@ class NimbblReactNativeSDK: RCTEventEmitter, NimbblCheckoutSDKDelegate {
         NimbblCheckoutSDK.shared.delegate = self
     }
     
-    override func supportedEvents() -> [String]! {
-        return [
-            "checkout_response"
-        ]
-    }
-    
-    override func constantsToExport() -> [AnyHashable: Any]! {
-        return [
-            "SDK_VERSION": "1.0.0",
-            "PLATFORM": "ios"
-        ]
-    }
     
     override static func requiresMainQueueSetup() -> Bool {
         return false
     }
     
-    override func startObserving() {
-        hasListeners = true
-    }
-    
-    override func stopObserving() {
-        hasListeners = false
-    }
     
     @objc
     override func addListener(_ eventName: String!) {
@@ -62,19 +42,14 @@ class NimbblReactNativeSDK: RCTEventEmitter, NimbblCheckoutSDKDelegate {
             
             // Extract configuration
             self.config.removeAll()
-            self.config["environment"] = config["environment"] as? String ?? "production"
-            
-            if let options = config["options"] as? [String: Any] {
-                self.config["timeout"] = options["timeout"] as? Int ?? 30000
-                self.config["enable_logging"] = options["enable_logging"] as? Bool ?? false
-                self.config["enable_analytics"] = options["enable_analytics"] as? Bool ?? true
-                self.config["api_base_url"] = options["api_base_url"] as? String ?? "https://api.nimbbl.tech"
-            }
+            self.config["api_base_url"] = config["api_base_url"] as? String ?? "https://api.nimbbl.tech"
             
             // Set environment URL on the native SDK during initialization
             let apiBaseUrl = self.config["api_base_url"] as? String
             if let apiBaseUrl = apiBaseUrl {
-                NimbblCheckoutSDK.shared.environmentUrl = apiBaseUrl
+                // Ensure URL ends with / to prevent URL construction issues
+                let normalizedUrl = apiBaseUrl.hasSuffix("/") ? apiBaseUrl : apiBaseUrl + "/"
+                NimbblCheckoutSDK.shared.environmentUrl = normalizedUrl
             }
             
             isInitialized = true
@@ -199,11 +174,9 @@ class NimbblReactNativeSDK: RCTEventEmitter, NimbblCheckoutSDKDelegate {
     
     func onCheckoutResponse(data: [AnyHashable: Any]) {
         if let callback = checkoutCallback {
-            // Use direct callback if available
+            // Use direct callback
             callback([data])
-        } else if hasListeners {
-            // Fallback to event emitter
-            sendEvent(withName: "checkout_response", body: data)
         }
+        // Note: Removed fallback to event emitter for cleaner implementation
     }
 }

package/lib/NimbblSDK.d.ts

@@ -1,11 +1,11 @@
 /**
  * @fileoverview Main Nimbbl SDK for React Native
- * @version 1.2.0
+ * @version 1.3.0
  * @author Nimbbl Tech
  *
  * This is a wrapper around the native Android and iOS SDKs
  */
-import { SDKConfig } from './types';
+import { SDKConfig, CheckoutOptions } from './types';
 /**
  * Main Nimbbl SDK Class
  * Provides the primary interface for integrating Nimbbl payment functionality
@@ -15,8 +15,6 @@ export default class NimbblSDK {
     private static shared;
     private config;
     private isInitialized;
-    private eventEmitter;
-    private eventListeners;
     constructor();
     /**
      * Get shared instance (matching iOS pattern)
@@ -53,33 +51,7 @@ export default class NimbblSDK {
      * @param options - Checkout options
      * @returns Promise resolving to checkout result
      */
-    checkout(options: {
-        orderToken: string;
-        paymentModeCode?: string;
-        bankCode?: string;
-        walletCode?: string;
-        paymentFlow?: string;
-    }): Promise<{
-        success: boolean;
-        message?: string;
-        data?: any;
-    }>;
-    /**
-     * Add unified checkout response listener (recommended approach)
-     * This method handles both success and failure cases in a single callback
-     * @param listener - Callback function that receives checkout response data
-     */
-    addCheckoutResponseListener(listener: (data: any) => void): void;
-    /**
-     * Remove unified checkout response listener
-     * @param listener - Callback function to remove
-     */
-    removeCheckoutResponseListener(listener: (data: any) => void): void;
-    /**
-     * Validate SDK configuration
-     * @param config - Configuration to validate
-     */
-    private validateConfig;
+    checkout(options: CheckoutOptions): Promise<any>;
 }
 export declare const nimbblSDK: NimbblSDK;
 //# sourceMappingURL=NimbblSDK.d.ts.map