@yuno-payments/yuno-sdk-react-native 1.0.16 → 1.0.17-rc.10

package/YunoSdk.podspec

@@ -0,0 +1,48 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+folly_compiler_flags = '-DFOLLY_NO_CONFIG -DFOLLY_MOBILE=1 -DFOLLY_USE_LIBCPP=1 -Wno-comma -Wno-shorten-64-to-32'
+
+Pod::Spec.new do |s|
+  s.name         = "YunoSdk"
+  s.version      = package["version"]
+  s.summary      = package["description"]
+  s.homepage     = package["homepage"]
+  s.license      = package["license"]
+  s.authors      = package["author"]
+
+  s.platforms    = { :ios => "14.0" }
+  s.source       = { :git => "https://github.com/yuno-payments/yuno-sdk-react-native.git", :tag => "#{s.version}" }
+
+  s.source_files = "ios/**/*.{h,m,mm,swift}"
+
+  # Use install_modules_dependencies helper to install the dependencies if React Native version >=0.71.0.
+  # See https://github.com/facebook/react-native/blob/febf6b7f33fdb4904669f99d795eba4c0f95d7bf/scripts/cocoapods/new_architecture.rb#L79.
+  if respond_to?(:install_modules_dependencies, true)
+    install_modules_dependencies(s)
+  else
+    s.dependency "React-Core"
+
+    # 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-Codegen"
+      s.dependency "RCT-Folly"
+      s.dependency "RCTRequired"
+      s.dependency "RCTTypeSafety"
+      s.dependency "ReactCommon/turbomodule/core"
+    end
+  end
+
+  # Yuno iOS SDK
+  s.dependency "YunoSDK", "2.7.1"
+  
+  s.swift_version = '5.0'
+  s.static_framework = true
+end
+

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

@@ -2,6 +2,7 @@ package com.yunosdkreactnative
 
 import android.app.Activity
 import android.content.Context
+import android.util.Log
 import androidx.activity.ComponentActivity
 import com.facebook.react.bridge.*
 import com.facebook.react.modules.core.DeviceEventManagerModule
@@ -10,12 +11,26 @@ import com.yuno.sdk.YunoConfig
 import com.yuno.sdk.YunoLanguage
 import com.yuno.sdk.enrollment.*
 import com.yuno.sdk.payments.*
+import com.yuno.sdk.ApiClientPayment
+import com.yuno.sdk.ApiClientPayment.Companion.generateToken
+import com.yuno.sdk.ApiClientPayment.Companion.getThreeDSecureChallenge
+import com.yuno.sdk.ApiClientEnroll
+import com.yuno.sdk.ApiClientEnroll.Companion.continueEnrollment
+import com.yuno.sdk.payments.TokenCollectedData
+import com.yuno.sdk.enrollment.EnrollmentCollectedData
+import com.yuno.sdk.ThreeDSecureChallengeResponse
 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
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.flow.launchIn
+import kotlinx.coroutines.flow.onEach
+import kotlinx.coroutines.flow.catch
+import androidx.lifecycle.asFlow
 
 /**
  * Yuno SDK React Native Module for Android
@@ -51,6 +66,14 @@ class YunoSdkModule(private val reactContext: ReactApplicationContext) :
         @Volatile
         private var lastOneTimeTokenInfo: OneTimeTokenModel? = null
         
+        // Store the last payment status to prevent stale status from previous flows
+        @Volatile
+        private var lastPaymentStatus: String? = null
+        
+        // Flag to track if we're starting a fresh payment flow
+        @Volatile
+        private var isPaymentFlowCleared: Boolean = false
+        
         // Gson instance for JSON serialization
         private val gson = Gson()
         
@@ -612,6 +635,24 @@ class YunoSdkModule(private val reactContext: ReactApplicationContext) :
         }
     }
 
+    /**
+     * Clears the last stored payment status.
+     * This should be called at the start of each new payment flow
+     * to prevent stale status from previous flows.
+     */
+    @ReactMethod
+    fun clearLastPaymentStatus(promise: Promise) {
+        try {
+            // Don't set to null - keep the last status to compare against stale events
+            // Just mark that we're starting a fresh flow
+            isPaymentFlowCleared = true
+            Log.d(TAG, "💫 Payment status cleared - fresh flow starting (last status was: $lastPaymentStatus)")
+            promise.resolve(true)
+        } catch (e: Exception) {
+            promise.reject("CLEAR_STATUS_ERROR", "Error clearing last payment status: ${e.message}", e)
+        }
+    }
+
     // Lifecycle Methods
     override fun onHostResume() {}
     override fun onHostPause() {}
@@ -651,6 +692,26 @@ class YunoSdkModule(private val reactContext: ReactApplicationContext) :
 
     internal fun sendPaymentStatusEvent(status: String?) {
         val convertedStatus = convertPaymentStatus(status)
+        
+        // If we just cleared the status and this is the same status as before,
+        // it's a stale event from the native SDK - ignore it
+        if (isPaymentFlowCleared && convertedStatus == lastPaymentStatus) {
+            Log.d(TAG, "🚫 Ignoring stale payment status: $convertedStatus (from previous flow)")
+            isPaymentFlowCleared = false
+            lastPaymentStatus = null  // Clear it now that we've ignored the stale event
+            return
+        }
+        
+        // Reset the cleared flag after processing first real new event
+        if (isPaymentFlowCleared) {
+            Log.d(TAG, "✅ First new status after clear: $convertedStatus (previous was: $lastPaymentStatus)")
+            isPaymentFlowCleared = false
+        }
+        
+        // Store the current status for future comparison
+        lastPaymentStatus = convertedStatus
+        
+        Log.d(TAG, "✅ Emitting payment status: $convertedStatus")
         val params = Arguments.createMap().apply {
             putString("status", convertedStatus)
         }
@@ -774,4 +835,284 @@ class YunoSdkModule(private val reactContext: ReactApplicationContext) :
         }
         return array
     }
+
+    // ==================== HEADLESS PAYMENT FLOW ====================
+
+    /**
+     * Generate a one-time token (OTT) from collected payment data using the headless flow.
+     * This method mirrors the native SDK's generateToken() API.
+     * 
+     * @param tokenCollectedData Map containing checkout_session, customer_session, and payment_method data
+     * @param checkoutSession The checkout session ID
+     * @param countryCode The country code for the payment
+     * @param promise Promise to resolve with token or error
+     */
+    @ReactMethod
+    fun generateToken(
+        tokenCollectedData: ReadableMap,
+        checkoutSession: String,
+        countryCode: String,
+        promise: Promise
+    ) {
+        try {
+            Log.d(TAG, "generateToken called with checkoutSession: $checkoutSession")
+            
+            val activity = currentActivity
+            if (activity == null) {
+                promise.reject("ACTIVITY_UNAVAILABLE", "Current activity is null. Cannot generate token.")
+                return
+            }
+            
+            // Convert ReadableMap to TokenCollectedData using Gson
+            val gson = Gson()
+            val jsonString = convertReadableMapToJson(tokenCollectedData)
+            Log.d(TAG, "JSON String: $jsonString")
+            val collectedData = gson.fromJson(jsonString, TokenCollectedData::class.java)
+            Log.d(TAG, "Parsed TokenCollectedData: checkoutSession=${collectedData.checkoutSession}, paymentMethod=${collectedData.paymentMethod}")
+            
+            // Create API client
+            val apiClient = Yuno.apiClientPayment(
+                checkoutSession = checkoutSession,
+                countryCode = countryCode,
+                context = activity.applicationContext
+            )
+            
+            // Generate token - pass activity for WebView context
+            apiClient.generateToken(collectedData, activity)
+                .asFlow()
+                .onEach { result ->
+                    try {
+                        when {
+                            result.containsKey("token") && result["token"] != null -> {
+                                val token = result["token"] as String
+                                Log.d(TAG, "✅ Token generated successfully")
+                                
+                                val response = Arguments.createMap().apply {
+                                    putString("token", token)
+                                }
+                                promise.resolve(response)
+                            }
+                            result.containsKey("error") && result["error"] != null -> {
+                                val error = result["error"] as String
+                                Log.e(TAG, "❌ Token generation failed: $error")
+                                promise.reject("TOKEN_GENERATION_ERROR", error)
+                            }
+                            else -> {
+                                Log.e(TAG, "❌ Unknown response from token generation")
+                                promise.reject("TOKEN_GENERATION_ERROR", "Unknown error occurred")
+                            }
+                        }
+                    } catch (e: Exception) {
+                        Log.e(TAG, "❌ Error processing token generation result: ${e.message}")
+                        promise.reject("TOKEN_GENERATION_ERROR", e.message)
+                    }
+                }
+                .catch { e ->
+                    Log.e(TAG, "❌ Flow error in token generation: ${e.message}")
+                    promise.reject("TOKEN_GENERATION_ERROR", e.message ?: "Unknown error in token generation flow")
+                }
+                .launchIn(CoroutineScope(Dispatchers.Main))
+        } catch (e: Exception) {
+            Log.e(TAG, "❌ Error in generateToken: ${e.message}")
+            promise.reject("TOKEN_GENERATION_ERROR", e.message)
+        }
+    }
+
+    /**
+     * Get the 3D Secure challenge URL for a checkout session.
+     * This method mirrors the native SDK's getThreeDSecureChallenge() API.
+     * 
+     * @param checkoutSession The checkout session ID
+     * @param countryCode The country code for the payment
+     * @param promise Promise to resolve with URL or error
+     */
+    @ReactMethod
+    fun getThreeDSecureChallenge(
+        checkoutSession: String,
+        countryCode: String,
+        promise: Promise
+    ) {
+        try {
+            Log.d(TAG, "getThreeDSecureChallenge called with checkoutSession: $checkoutSession")
+            
+            val activity = currentActivity
+            if (activity == null) {
+                promise.reject("ACTIVITY_UNAVAILABLE", "Current activity is null. Cannot get 3DS challenge.")
+                return
+            }
+            
+            // Create API client
+            val apiClient = Yuno.apiClientPayment(
+                checkoutSession = checkoutSession,
+                countryCode = countryCode,
+                context = activity.applicationContext
+            )
+            
+            // Get 3DS challenge - pass activity for WebView context
+            apiClient.getThreeDSecureChallenge(activity, checkoutSession)
+                .asFlow()
+                .onEach { result ->
+                    try {
+                        val response = Arguments.createMap().apply {
+                            putString("type", result.type)
+                            putString("data", result.data)
+                        }
+                        
+                        if (result.type == "URL") {
+                            Log.d(TAG, "✅ 3DS Challenge URL retrieved successfully")
+                            promise.resolve(response)
+                        } else {
+                            Log.e(TAG, "❌ 3DS Challenge failed: ${result.data}")
+                            promise.reject("THREE_DS_ERROR", result.data)
+                        }
+                    } catch (e: Exception) {
+                        Log.e(TAG, "❌ Error processing 3DS challenge result: ${e.message}")
+                        promise.reject("THREE_DS_ERROR", e.message)
+                    }
+                }
+                .catch { e ->
+                    Log.e(TAG, "❌ Flow error in 3DS challenge: ${e.message}")
+                    promise.reject("THREE_DS_ERROR", e.message ?: "Unknown error in 3DS challenge flow")
+                }
+                .launchIn(CoroutineScope(Dispatchers.Main))
+        } catch (e: Exception) {
+            Log.e(TAG, "❌ Error in getThreeDSecureChallenge: ${e.message}")
+            promise.reject("THREE_DS_ERROR", e.message)
+        }
+    }
+
+    // ==================== HEADLESS ENROLLMENT FLOW ====================
+
+    @ReactMethod
+    fun continueEnrollment(
+        enrollmentCollectedData: ReadableMap,
+        customerSession: String,
+        countryCode: String,
+        promise: Promise
+    ) {
+        try {
+            Log.d(TAG, "continueEnrollment called with customerSession: $customerSession")
+
+            val activity = currentActivity
+            if (activity == null) {
+                promise.reject("ACTIVITY_UNAVAILABLE", "Current activity is null. Cannot continue enrollment.")
+                return
+            }
+
+            // Convert ReadableMap to JSON String
+            val jsonString = convertReadableMapToJson(enrollmentCollectedData)
+            Log.d(TAG, "📦 EnrollmentCollectedData JSON received: $jsonString")
+
+            // Convert JSON String to EnrollmentCollectedData using Gson
+            val gson = Gson()
+            val collectedData = gson.fromJson(jsonString, EnrollmentCollectedData::class.java)
+
+            // Create API client for enrollment
+            val apiClient = Yuno.apiClientEnroll(
+                customerSession = customerSession,
+                countryCode = countryCode,
+                context = activity
+            )
+
+            // Continue enrollment
+            apiClient.continueEnrollment(collectedData, activity)
+                .asFlow()
+                .onEach { result ->
+                    try {
+                        when {
+                            result.containsKey("vaulted_token") && result["vaulted_token"] != null -> {
+                                val vaultedToken = result["vaulted_token"] as String
+                                Log.d(TAG, "✅ Vaulted token created successfully")
+
+                                val response = Arguments.createMap().apply {
+                                    putString("vaultedToken", vaultedToken)
+                                }
+                                promise.resolve(response)
+                            }
+                            result.containsKey("error") && result["error"] != null -> {
+                                val error = result["error"] as String
+                                Log.e(TAG, "❌ Enrollment failed: $error")
+                                promise.reject("ENROLLMENT_ERROR", error)
+                            }
+                            else -> {
+                                Log.e(TAG, "❌ Unknown response from enrollment")
+                                promise.reject("ENROLLMENT_ERROR", "Unknown error occurred")
+                            }
+                        }
+                    } catch (e: Exception) {
+                        Log.e(TAG, "❌ Error processing enrollment result: ${e.message}")
+                        promise.reject("ENROLLMENT_ERROR", e.message)
+                    }
+                }
+                .catch { e ->
+                    Log.e(TAG, "❌ Flow error during enrollment: ${e.message}")
+                    promise.reject("ENROLLMENT_FLOW_ERROR", e.message)
+                }
+                .launchIn(CoroutineScope(Dispatchers.Main))
+        } catch (e: Exception) {
+            Log.e(TAG, "❌ Error in continueEnrollment: ${e.message}")
+            promise.reject("ENROLLMENT_ERROR", e.message)
+        }
+    }
+
+    /**
+     * Helper function to convert ReadableMap to JSON string.
+     */
+    private fun convertReadableMapToJson(readableMap: ReadableMap): String {
+        val json = JSONObject()
+        val iterator = readableMap.keySetIterator()
+        
+        while (iterator.hasNextKey()) {
+            val key = iterator.nextKey()
+            val value = when (readableMap.getType(key)) {
+                ReadableType.Boolean -> readableMap.getBoolean(key)
+                ReadableType.Number -> readableMap.getDouble(key)
+                ReadableType.String -> readableMap.getString(key)
+                ReadableType.Map -> convertReadableMapToJsonObject(readableMap.getMap(key)!!)
+                ReadableType.Array -> convertReadableArrayToJsonArray(readableMap.getArray(key)!!)
+                ReadableType.Null -> JSONObject.NULL
+            }
+            json.put(key, value)
+        }
+        
+        return json.toString()
+    }
+
+    private fun convertReadableMapToJsonObject(readableMap: ReadableMap): JSONObject {
+        val json = JSONObject()
+        val iterator = readableMap.keySetIterator()
+        
+        while (iterator.hasNextKey()) {
+            val key = iterator.nextKey()
+            val value = when (readableMap.getType(key)) {
+                ReadableType.Boolean -> readableMap.getBoolean(key)
+                ReadableType.Number -> readableMap.getDouble(key)
+                ReadableType.String -> readableMap.getString(key)
+                ReadableType.Map -> convertReadableMapToJsonObject(readableMap.getMap(key)!!)
+                ReadableType.Array -> convertReadableArrayToJsonArray(readableMap.getArray(key)!!)
+                ReadableType.Null -> JSONObject.NULL
+            }
+            json.put(key, value)
+        }
+        
+        return json
+    }
+
+    private fun convertReadableArrayToJsonArray(readableArray: ReadableArray): JSONArray {
+        val json = JSONArray()
+        
+        for (i in 0 until readableArray.size()) {
+            val value = when (readableArray.getType(i)) {
+                ReadableType.Boolean -> readableArray.getBoolean(i)
+                ReadableType.Number -> readableArray.getDouble(i)
+                ReadableType.String -> readableArray.getString(i)
+                ReadableType.Map -> convertReadableMapToJsonObject(readableArray.getMap(i))
+                ReadableType.Array -> convertReadableArrayToJsonArray(readableArray.getArray(i))
+                ReadableType.Null -> JSONObject.NULL
+            }
+            json.put(value)
+        }
+        
+        return json
+    }
 }

package/ios/YunoPaymentMethodsViewManager.m

@@ -0,0 +1,10 @@
+#import <React/RCTViewManager.h>
+
+@interface RCT_EXTERN_MODULE(YunoPaymentMethodsViewManager, RCTViewManager)
+
+// Export props
+RCT_EXPORT_VIEW_PROPERTY(checkoutSession, NSString)
+RCT_EXPORT_VIEW_PROPERTY(countryCode, NSString)
+
+@end
+