nimbbl-mobile-react-native-sdk 1.0.0-alpha.5

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

@@ -0,0 +1,428 @@
+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.models.NimbblCheckoutOptions
+import tech.nimbbl.webviewsdk.models.interfaces.NimbblCheckoutPaymentListener
+import kotlinx.coroutines.*
+import retrofit2.Response
+
+class NimbblReactNativeSDKModule(private val reactContext: ReactApplicationContext) : 
+    ReactContextBaseJavaModule(reactContext), ActivityEventListener {
+    
+    companion object {
+        private const val TAG = "NimbblReactNativeSDK"
+    }
+    
+    private var config: MutableMap<String, Any> = mutableMapOf()
+    private var isInitialized = false
+    
+    init {
+        reactContext.addActivityEventListener(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 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")
+            }
+            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
+            }
+
+            // 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"
+            }
+
+            isInitialized = true
+            
+            val result = Arguments.createMap().apply {
+                putBoolean("success", true)
+                putString("message", "SDK initialized successfully")
+            }
+            
+            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
+            }
+            
+            // Handle user parameter - it might be undefined, null, or valid data from React Native
+            val userMap = orderData.getMap("user")
+            val user: Map<String, Any>? = if (userMap != null && !userMap.toHashMap().isEmpty()) {
+                userMap.toHashMap()
+            } else {
+                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)
+            }
+            
+            // 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")
+                
+                // Use direct method call with coroutine (since createOrder is a suspend function)
+                // Convert amount string to int
+                val amountInt = amountString.toIntOrNull() ?: 0
+                
+                // Use coroutine to call suspend function
+                val orderResult = runBlocking {
+                    NimbblOrderCreation.createOrder(
+                        apiBaseUrl,
+                        amountInt, // Use amount as int
+                        userEmail,
+                        userName,
+                        userMobile,
+                        productId,
+                        paymentMode, // Use paymentMode as paymentModeCode
+                        "" // bankCode (empty for now)
+                    )
+                }
+                
+                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("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)
+        }
+    }
+
+
+
+    @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") ?: ""
+            val bankCode = options.getString("bank_code") ?: ""
+            val walletCode = options.getString("wallet_code") ?: ""
+            val paymentFlow = options.getString("payment_flow") ?: ""
+            
+            if (orderToken.isNullOrEmpty()) {
+                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...")
+            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)
+                }
+                
+                // Use a request code to identify this activity result
+                val REQUEST_CHECKOUT = 1001
+                currentActivity.startActivityForResult(intent, REQUEST_CHECKOUT)
+                
+                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
+            }
+            
+            val result = Arguments.createMap().apply {
+                putString("status", "checkout_opened")
+            }
+            
+            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") ?: "")
+                    }
+                    sendEvent("payment_success", params)
+                }
+                "failed" -> {
+                    val params = Arguments.createMap().apply {
+                        putString("status", "failed")
+                        putString("data", data.getStringExtra("response") ?: "")
+                    }
+                    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
+                }
+            }
+        }
+    }
+
+    override fun onNewIntent(intent: Intent?) {
+        // Handle new intents if needed
+    }
+    
+    override fun onCatalystInstanceDestroy() {
+        super.onCatalystInstanceDestroy()
+        reactContext.removeActivityEventListener(this)
+    }
+    
+}

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

@@ -0,0 +1,16 @@
+package com.nimbbl.reactnative
+
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ViewManager
+
+class NimbblReactNativeSDKPackage : ReactPackage {
+    override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
+        return listOf(NimbblReactNativeSDKModule(reactContext))
+    }
+
+    override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
+        return emptyList()
+    }
+}

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

@@ -0,0 +1,28 @@
+package com.nimbbl.reactnative
+
+import android.app.Activity
+import android.os.Bundle
+import android.util.Log
+import android.widget.TextView
+
+class TestActivity : Activity() {
+    
+    companion object {
+        private const val TAG = "TestActivity"
+    }
+    
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        
+        Log.d(TAG, "TestActivity onCreate called")
+        println("TestActivity onCreate called")
+        
+        // Create a simple TextView
+        val textView = TextView(this)
+        textView.text = "Test Activity is working!"
+        setContentView(textView)
+        
+        Log.d(TAG, "TestActivity setup complete")
+        println("TestActivity setup complete")
+    }
+}

package/index.tsx

@@ -0,0 +1,8 @@
+/**
+ * @fileoverview Main entry point for Nimbbl React Native SDK
+ * @version 1.0.0
+ * @author Nimbbl Tech
+ */
+
+// Re-export everything from the built TypeScript files
+module.exports = require('./lib/index.js');

package/ios/NimbblReactNativeSDK.m

@@ -0,0 +1,20 @@
+#import <React/RCTBridgeModule.h>
+
+@interface RCT_EXTERN_MODULE(NimbblReactNativeSDK, NSObject)
+
+RCT_EXTERN_METHOD(testModule:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(initialize:(NSDictionary *)config
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(createShopOrder:(NSDictionary *)orderData
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(checkout:(NSDictionary *)options
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+@end

package/ios/NimbblReactNativeSDK.podspec

@@ -0,0 +1,38 @@
+require 'json'
+
+package = JSON.parse(File.read(File.join(__dir__, '..', 'package.json')))
+
+Pod::Spec.new do |s|
+  s.name         = 'NimbblReactNativeSDK'
+  s.version      = package['version']
+  s.summary      = package['description']
+  s.homepage     = package['homepage']
+  s.license      = package['license']
+  s.author       = package['author']
+  s.platform     = :ios, "13.0"
+  s.source       = { :git => "https://github.com/nimbbl-tech/nimbbl_mobile_kit_react_native_sdk.git", :tag => "#{s.version}" }
+  s.source_files = "*.{h,m,swift}"
+  s.swift_version = '5.0'
+  s.requires_arc = true
+
+  s.dependency "React-Core"
+  
+  # Nimbbl WebView SDK dependency (includes all necessary dependencies)
+  s.dependency "nimbbl_mobile_kit_ios_webview_sdk", "~> 1.0.12"
+  
+  # Don't install the dependencies when we run `pod install` in the old architecture.
+  if ENV['RCT_NEW_ARCH_ENABLED'] == '1' then
+    s.compiler_flags = folly_compiler_flags + " -DRCT_NEW_ARCH_ENABLED=1"
+    s.pod_target_xcconfig    = {
+        "HEADER_SEARCH_PATHS" => "\"$(PODS_ROOT)/boost\"",
+        "OTHER_CPLUSPLUSFLAGS" => "-DFOLLY_NO_CONFIG -DFOLLY_MOBILE=1 -DFOLLY_USE_LIBCPP=1",
+        "CLANG_CXX_LANGUAGE_STANDARD" => "c++17"
+    }
+    s.dependency "React-RCTFabric"
+    s.dependency "React-Codegen"
+    s.dependency "RCT-Folly"
+    s.dependency "RCTRequired"
+    s.dependency "RCTTypeSafety"
+    s.dependency "ReactCommon/turbomodule/core"
+  end
+end