@finos_sdk/sdk-ekyc 1.2.2 → 1.2.8

package/android/src/main/java/finos/sdk/ekyc/EKYCModule.kt

@@ -8,6 +8,7 @@ import com.facebook.react.bridge.Promise
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.bridge.ReactContextBaseJavaModule
 import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.bridge.WritableArray
 import com.facebook.react.bridge.WritableMap
 import com.facebook.react.module.annotations.ReactModule
 import com.facebook.react.modules.core.DeviceEventManagerModule
@@ -31,6 +32,11 @@ import finos.sdk.faceservice.SdkEkycFaceService
 import finos.sdk.liveness.SdkEkycLiveness
 import finos.sdk.nfc.SdkEkycNfc
 import finos.sdk.ocr.SdkEkycOcr
+import finos.sdk.smsotp.SdkSmsOtpService
+import finos.sdk.core.model.sdk.config.SmsOtpConfig
+import vn.softdreams.easyca.sdk.SdkeSign
+import vn.softdreams.easyca.sdk.utils.UserEsignModel
+import org.json.JSONObject
 import java.io.File
 import java.io.FileOutputStream
 import java.util.Date
@@ -51,20 +57,50 @@ class EKYCModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMo
             .emit(eventName, params)
     }
 
+    /**
+     * Helper function to create separate maps for event and promise to avoid "Map already consumed" error
+     * @param builder Lambda function to build the map content
+     * @return Pair of (eventMap, promiseMap)
+     */
+    private fun createSeparateMaps(builder: (WritableMap) -> Unit): Pair<WritableMap, WritableMap> {
+        val eventMap = Arguments.createMap().apply(builder)
+        val promiseMap = Arguments.createMap().apply(builder)
+        return Pair(eventMap, promiseMap)
+    }
+
+    /**
+     * Helper function to create separate maps with array for event and promise
+     * @param arrayBuilder Lambda function to build the array content
+     * @param mapBuilder Lambda function to build the map with array
+     * @return Pair of (eventMap, promiseMap)
+     */
+    private fun createSeparateMapsWithArray(
+        arrayBuilder: (WritableArray) -> Unit,
+        mapBuilder: (WritableMap, WritableArray) -> Unit
+    ): Pair<WritableMap, WritableMap> {
+        val eventArray = Arguments.createArray().apply(arrayBuilder)
+        val promiseArray = Arguments.createArray().apply(arrayBuilder)
+        val eventMap = Arguments.createMap().apply { mapBuilder(this, eventArray) }
+        val promiseMap = Arguments.createMap().apply { mapBuilder(this, promiseArray) }
+        return Pair(eventMap, promiseMap)
+    }
+
     @ReactMethod
     fun initSdkEkyc(promise: Promise) {
+        Log.d(TAG, "▶️ initSdkEkyc() called")
         try {
             SdkEkyc.initSDKEkyc(reactApplicationContext) {
+                Log.d(TAG, "✅ initSdkEkyc() success")
                 val params =
                     Arguments.createMap().apply {
                         putString("status", "success")
                         putString("message", "SDK EKYC initialized successfully")
                     }
                 sendEvent("EKYCInitEvent", params)
-                //promise.resolve("SDK EKYC initialized successfully")
                 promise.resolve(true)
             }
         } catch (e: Exception) {
+            Log.e(TAG, "❌ initSdkEkyc() failed: ${e.message}", e)
             promise.reject("INIT_ERROR", "Failed to initialize SDK EKYC: ${e.message}")
         }
     }
@@ -79,14 +115,14 @@ class EKYCModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMo
         facePathStorage: String?,
         promise: Promise
     ) {
+        Log.d(TAG, "▶️ startNfcScan() called")
         try {
-            Log.d(TAG, "startNfcScan:::0000")
             val currentActivity = reactApplicationContext.currentActivity
             if (currentActivity == null) {
+                Log.e(TAG, "❌ startNfcScan() failed: Activity not available")
                 promise.reject("NO_ACTIVITY", "Activity not available")
                 return
             }
-            Log.d(TAG, "startNfcScan:::1111")
             val nfcConfig = NfcConfig(
                 documentNumber = documentNumber,
                 birthDate = birthDate,
@@ -115,6 +151,7 @@ class EKYCModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMo
                         }
 
                         EKYCEvent.SCAN_NFC_SUCCESS -> {
+                            Log.d(TAG, "✅ startNfcScan() success")
                             val eventMap =
                                 Arguments.createMap().apply {
                                     putString("event", event.name.toString())
@@ -140,7 +177,7 @@ class EKYCModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMo
                     }
                 },
                 callbackError = { event, message ->
-                    Log.e(TAG, "NFC Error - Event: $event, Message: $message")
+                    Log.e(TAG, "❌ startNfcScan() failed - Event: $event, Message: $message")
 
                     val errorMap =
                         Arguments.createMap().apply {
@@ -152,9 +189,8 @@ class EKYCModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMo
                     promise.reject(event.name.toString(), message?.toString() ?: "Unknown NFC error")
                 }
             )
-            Log.d(TAG, "startNfcScan:::222222")
         } catch (e: Exception) {
-            Log.e(TAG, "Exception in startNfcScan: ${e.message}", e)
+            Log.e(TAG, "❌ startNfcScan() exception: ${e.message}", e)
             promise.reject("NFC_EXCEPTION", e.message, e)
         }
     }
@@ -168,6 +204,7 @@ class EKYCModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMo
         transactionId: String?,
         promise: Promise
     ) {
+        Log.d(TAG, "▶️ checkC06() called")
         try {
             val c06Config =
                 C06Config(
@@ -182,7 +219,7 @@ class EKYCModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMo
             SdkEkycC06.startEkyc(
                 ekycConfigSDK = ekycConfig,
                 callbackSuccess = { event, data ->
-                    Log.d(TAG, "C06 Success - Event: $event, Data: $data")
+                    Log.d(TAG, "✅ checkC06() success")
 
                     // Create separate maps for event and promise
                     val eventMap =
@@ -200,7 +237,7 @@ class EKYCModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMo
                     promise.resolve(promiseMap)
                 },
                 callbackError = { event, message ->
-                    Log.e(TAG, "C06 Error - Event: $event, Message: $message")
+                    Log.e(TAG, "❌ checkC06() failed - Event: $event, Message: $message")
 
                     val errorMap =
                         Arguments.createMap().apply {
@@ -213,7 +250,7 @@ class EKYCModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMo
                 }
             )
         } catch (e: Exception) {
-            Log.e(TAG, "Exception in checkC06: ${e.message}", e)
+            Log.e(TAG, "❌ checkC06() exception: ${e.message}", e)
             promise.reject("C06_EXCEPTION", e.message, e)
         }
     }
@@ -226,9 +263,11 @@ class EKYCModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMo
         transactionId: String,
         promise: Promise
     ) {
+        Log.d(TAG, "▶️ startOcr() called")
         try {
             val currentActivity = reactApplicationContext.currentActivity
             if (currentActivity == null) {
+                Log.e(TAG, "❌ startOcr() failed: Activity not available")
                 promise.reject("NO_ACTIVITY", "Activity not available")
                 return
             }
@@ -249,28 +288,16 @@ class EKYCModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMo
             SdkEkycOcr.startEkyc(
                 ekycConfigSDK = ekycConfig,
                 callbackSuccess = { event, data ->
-                    Log.d(TAG, "OCR Success - Event: $event, Data: $data")
-                    val resultMap =
-                        Arguments.createMap().apply {
-                            putString("event", event.name.toString())
-                            putString(
-                                "data",
-                                (data as SDKEkycResult).ocrResponse.toString()
-                            )
-                        }
-                    sendEvent("onOcrSuccess", resultMap)
-                    val promiseMap =
-                        Arguments.createMap().apply {
-                            putString("event", event.name.toString())
-                            putString(
-                                "data",
-                                (data as SDKEkycResult).ocrResponse.toString()
-                            )
-                        }
+                    Log.d(TAG, "✅ startOcr() success")
+                    val (eventMap, promiseMap) = createSeparateMaps { map ->
+                        map.putString("event", event.name.toString())
+                        map.putString("data", (data as SDKEkycResult).ocrResponse.toString())
+                    }
+                    sendEvent("onOcrSuccess", eventMap)
                     promise.resolve(promiseMap)
                 },
                 callbackError = { event, message ->
-                    Log.e(TAG, "OCR Error - Event: $event, Message: $message")
+                    Log.e(TAG, "❌ startOcr() failed - Event: $event, Message: $message")
                     val errorMap =
                         Arguments.createMap().apply {
                             putString("event", event.name.toString())
@@ -281,7 +308,7 @@ class EKYCModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMo
                 }
             )
         } catch (e: Exception) {
-            Log.e(TAG, "Exception in startOcr: ${e.message}", e)
+            Log.e(TAG, "❌ startOcr() exception: ${e.message}", e)
             promise.reject("OCR_ERROR", e.message)
         }
     }
@@ -296,9 +323,11 @@ class EKYCModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMo
         switchFrontCamera: Boolean?,
         promise: Promise
     ) {
+        Log.d(TAG, "▶️ startLiveness() called")
         try {
             val currentActivity = reactApplicationContext.currentActivity
             if (currentActivity == null) {
+                Log.e(TAG, "❌ startLiveness() failed: Activity not available")
                 promise.reject("NO_ACTIVITY", "Activity not available")
                 return
             }
@@ -325,28 +354,16 @@ class EKYCModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMo
             SdkEkycLiveness.startEkyc(
                 ekycConfigSDK = ekycConfig,
                 callbackSuccess = { event, data ->
-                    Log.d(TAG, "Liveness Success - Event: $event, Data: $data")
-                    val resultMap =
-                        Arguments.createMap().apply {
-                            putString("event", event.name.toString())
-                            putString(
-                                "data",
-                                (data as SDKEkycResult).checkLivenessResponse.toString()
-                            )
-                        }
-                    sendEvent("onLivenessSuccess", resultMap)
-                    val promiseMap =
-                        Arguments.createMap().apply {
-                            putString("event", event.name.toString())
-                            putString(
-                                "data",
-                                (data as SDKEkycResult).checkLivenessResponse.toString()
-                            )
-                        }
+                    Log.d(TAG, "✅ startLiveness() success")
+                    val (eventMap, promiseMap) = createSeparateMaps { map ->
+                        map.putString("event", event.name.toString())
+                        map.putString("data", (data as SDKEkycResult).checkLivenessResponse.toString())
+                    }
+                    sendEvent("onLivenessSuccess", eventMap)
                     promise.resolve(promiseMap)
                 },
                 callbackError = { event, message ->
-                    Log.e(TAG, "Liveness Error - Event: $event, Message: $message")
+                    Log.e(TAG, "❌ startLiveness() failed - Event: $event, Message: $message")
                     val errorMap =
                         Arguments.createMap().apply {
                             putString("event", event.name.toString())
@@ -357,7 +374,7 @@ class EKYCModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMo
                 }
             )
         } catch (e: Exception) {
-            Log.e(TAG, "Exception in startLiveness: ${e.message}", e)
+            Log.e(TAG, "❌ startLiveness() exception: ${e.message}", e)
             promise.reject("LIVENESS_ERROR", e.message)
         }
     }
@@ -370,9 +387,11 @@ class EKYCModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMo
         idImage: String,
         promise: Promise
     ) {
+        Log.d(TAG, "▶️ startFaceCompare() called")
         try {
             val currentActivity = reactApplicationContext.currentActivity
             if (currentActivity == null) {
+                Log.e(TAG, "❌ startFaceCompare() failed: Activity not available")
                 promise.reject("NO_ACTIVITY", "Activity not available")
                 return
             }
@@ -393,22 +412,16 @@ class EKYCModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMo
             SdkEkycFaceService.startEkyc(
                 ekycConfigSDK = ekycConfig,
                 callbackSuccess = { event, data ->
-                    Log.d(TAG, "Face Compare Success - Event: $event, Data: $data")
-                    val resultMap =
-                        Arguments.createMap().apply {
-                            putString("event", event.name.toString())
-                            putString("data", data.toString())
-                        }
-                    sendEvent("onFaceCompareSuccess", resultMap)
-                    val promiseMap =
-                        Arguments.createMap().apply {
-                            putString("event", event.name.toString())
-                            putString("data", data.toString())
-                        }
+                    Log.d(TAG, "✅ startFaceCompare() success")
+                    val (eventMap, promiseMap) = createSeparateMaps { map ->
+                        map.putString("event", event.name.toString())
+                        map.putString("data", data.toString())
+                    }
+                    sendEvent("onFaceCompareSuccess", eventMap)
                     promise.resolve(promiseMap)
                 },
                 callbackError = { event, message ->
-                    Log.e(TAG, "FaceService Error - Event: $event, Message: $message")
+                    Log.e(TAG, "❌ startFaceCompare() failed - Event: $event, Message: $message")
                     val errorMap =
                         Arguments.createMap().apply {
                             putString("event", event.name.toString())
@@ -419,7 +432,7 @@ class EKYCModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMo
                 }
             )
         } catch (e: Exception) {
-            Log.e(TAG, "Exception in startFaceCompare: ${e.message}", e)
+            Log.e(TAG, "❌ startFaceCompare() exception: ${e.message}", e)
             promise.reject("FACE_COMPARE_ERROR", e.message)
         }
     }
@@ -489,15 +502,15 @@ class EKYCModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMo
         styleConfigJson: String, // JSON string for style config
         promise: Promise
     ) {
+        Log.d(TAG, "▶️ startEkycUI() called")
         try {
             val currentActivity = currentActivity
             if (currentActivity == null) {
+                Log.e(TAG, "❌ startEkycUI() failed: Activity not available")
                 promise.reject("NO_ACTIVITY", "Activity not available")
                 return
             }
 
-            Log.d(TAG, "startEkycUI: appKey=$appKey, flowSDK=$flowSDK, language=$language, optionConfig=$optionConfigJson, appKeyConfig=$appKeyConfigJson, styleConfig=$styleConfigJson")
-
             // Parse flowSDK JSON string to List<SDKType>
             val flowList = parseFlowSDK(flowSDK)
 
@@ -535,29 +548,21 @@ class EKYCModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMo
                 flowSDK = finalFlow
             )
 
-            // Use actual SdkEkycUI.startEkyc like MainActivity.kt
-            Log.d(TAG, "Starting SdkEkycUI.startEkyc with config: $ekycConfigSDK")
-
             SdkEkycUI.startEkyc(
                 activity = currentActivity,
                 ekycConfigSDK = ekycConfigSDK,
                 callbackSuccess = { event, data ->
-                    Log.d(TAG, "eKYC UI Success - Event: $event, Data: $data")
-                    val resultMap = Arguments.createMap().apply {
-                        putString("status", "success")
-                        putString("event", event.name.toString())
-                        putString("data", data.toString())
-                    }
-                    val eventMap = Arguments.createMap().apply {
-                        putString("status", "success")
-                        putString("event", event.name.toString())
-                        putString("data", data.toString())
+                    Log.d(TAG, "✅ startEkycUI() success")
+                    val (eventMap, promiseMap) = createSeparateMaps { map ->
+                        map.putString("status", "success")
+                        map.putString("event", event.name.toString())
+                        map.putString("data", data.toString())
                     }
                     sendEvent("onEkycUISuccess", eventMap)
-                    promise.resolve(resultMap)
+                    promise.resolve(promiseMap)
                 },
                 callbackError = { event, errorResult ->
-                    Log.e(TAG, "eKYC UI Error - Event: $event, ErrorResult: $errorResult")
+                    Log.e(TAG, "❌ startEkycUI() failed - Event: $event, Message: ${errorResult.message}")
                     val errorMap = Arguments.createMap().apply {
                         putString("status", "error")
                         putString("event", event.name.toString())
@@ -576,7 +581,7 @@ class EKYCModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMo
             )
 
         } catch (e: Exception) {
-            Log.e(TAG, "Exception in startEkycUI: ${e.message}", e)
+            Log.e(TAG, "❌ startEkycUI() exception: ${e.message}", e)
             promise.reject("EKYC_UI_EXCEPTION", e.message, e)
         }
     }
@@ -784,4 +789,696 @@ class EKYCModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMo
         }
     }
 
+    // ==================== SMS OTP Methods ====================
+
+    @ReactMethod
+    fun sendOtp(
+        phoneNumber: String,
+        purpose: String?,
+        referenceId: String,
+        promise: Promise
+    ) {
+        Log.d(TAG, "▶️ sendOtp() called")
+        Log.d(TAG, "   📱 Phone: $phoneNumber")
+        Log.d(TAG, "   🎯 Purpose: ${purpose ?: "transaction"}")
+        Log.d(TAG, "   🔖 ReferenceId: $referenceId")
+        try {
+            val smsOtpConfig = SmsOtpConfig(
+                phoneNumber = phoneNumber,
+                purpose = purpose ?: "transaction",
+                referenceId = referenceId
+            )
+
+            SdkSmsOtpService.sendOtp(
+                smsOtpConfig = smsOtpConfig,
+                callbackSuccess = { event, result ->
+                    Log.d(TAG, "✅ sendOtp() success")
+                    val (eventMap, promiseMap) = createSeparateMaps { map ->
+                        map.putString("event", event.name.toString())
+                        result?.let {
+                            val dataMap = Arguments.createMap()
+                            it.customData?.forEach { (key, value) ->
+                                dataMap.putString(key, value.toString())
+                            }
+                            map.putMap("data", dataMap)
+                        }
+                    }
+                    sendEvent("onSmsOtpSendSuccess", eventMap)
+                    promise.resolve(promiseMap)
+                },
+                callbackError = { event, error ->
+                    Log.e(TAG, "❌ sendOtp() failed - Event: $event, Message: ${error.message}")
+                    Log.e(TAG, "   🔴 Error Code: ${error.code}")
+                    Log.e(TAG, "   📱 Phone: $phoneNumber, Purpose: ${purpose ?: "transaction"}, RefId: $referenceId")
+                    val errorMap = Arguments.createMap().apply {
+                        putString("event", event.name.toString())
+                        putString("message", error.message)
+                        putString("code", error.code)
+                    }
+                    sendEvent("onSmsOtpError", errorMap)
+                    promise.reject(event.name.toString(), error.message)
+                }
+            )
+        } catch (e: Exception) {
+            Log.e(TAG, "❌ sendOtp() exception: ${e.message}", e)
+            promise.reject("SMS_OTP_EXCEPTION", e.message, e)
+        }
+    }
+
+    @ReactMethod
+    fun verifyOtp(
+        phoneNumber: String,
+        purpose: String?,
+        referenceId: String,
+        requestId: String,
+        otpCode: String,
+        promise: Promise
+    ) {
+        Log.d(TAG, "▶️ verifyOtp() called")
+        try {
+            val smsOtpConfig = SmsOtpConfig(
+                phoneNumber = phoneNumber,
+                purpose = purpose ?: "transaction",
+                referenceId = referenceId,
+                requestId = requestId
+            )
+
+            SdkSmsOtpService.verifyOtp(
+                smsOtpConfig = smsOtpConfig,
+                otpCode = otpCode,
+                callbackSuccess = { event, result ->
+                    Log.d(TAG, "✅ verifyOtp() success")
+                    val (eventMap, promiseMap) = createSeparateMaps { map ->
+                        map.putString("event", event.name.toString())
+                        result?.let {
+                            val dataMap = Arguments.createMap()
+                            it.customData?.forEach { (key, value) ->
+                                dataMap.putString(key, value.toString())
+                            }
+                            map.putMap("data", dataMap)
+                        }
+                    }
+                    sendEvent("onSmsOtpVerifySuccess", eventMap)
+                    promise.resolve(promiseMap)
+                },
+                callbackError = { event, error ->
+                    Log.e(TAG, "❌ verifyOtp() failed - Event: $event, Message: ${error.message}")
+                    val errorMap = Arguments.createMap().apply {
+                        putString("event", event.name.toString())
+                        putString("message", error.message)
+                        putString("code", error.code)
+                    }
+                    sendEvent("onSmsOtpError", errorMap)
+                    promise.reject(event.name.toString(), error.message)
+                }
+            )
+        } catch (e: Exception) {
+            Log.e(TAG, "❌ verifyOtp() exception: ${e.message}", e)
+            promise.reject("SMS_OTP_EXCEPTION", e.message, e)
+        }
+    }
+
+    @ReactMethod
+    fun resendOtp(
+        phoneNumber: String,
+        purpose: String?,
+        referenceId: String,
+        requestId: String,
+        promise: Promise
+    ) {
+        Log.d(TAG, "▶️ resendOtp() called")
+        try {
+            val smsOtpConfig = SmsOtpConfig(
+                phoneNumber = phoneNumber,
+                purpose = purpose ?: "transaction",
+                referenceId = referenceId,
+                requestId = requestId
+            )
+
+            SdkSmsOtpService.resendOtp(
+                smsOtpConfig = smsOtpConfig,
+                callbackSuccess = { event, result ->
+                    Log.d(TAG, "✅ resendOtp() success")
+                    val (eventMap, promiseMap) = createSeparateMaps { map ->
+                        map.putString("event", event.name.toString())
+                        result?.let {
+                            val dataMap = Arguments.createMap()
+                            it.customData?.forEach { (key, value) ->
+                                dataMap.putString(key, value.toString())
+                            }
+                            map.putMap("data", dataMap)
+                        }
+                    }
+                    sendEvent("onSmsOtpResendSuccess", eventMap)
+                    promise.resolve(promiseMap)
+                },
+                callbackError = { event, error ->
+                    Log.e(TAG, "❌ resendOtp() failed - Event: $event, Message: ${error.message}")
+                    val errorMap = Arguments.createMap().apply {
+                        putString("event", event.name.toString())
+                        putString("message", error.message)
+                        putString("code", error.code)
+                    }
+                    sendEvent("onSmsOtpError", errorMap)
+                    promise.reject(event.name.toString(), error.message)
+                }
+            )
+        } catch (e: Exception) {
+            Log.e(TAG, "❌ resendOtp() exception: ${e.message}", e)
+            promise.reject("SMS_OTP_EXCEPTION", e.message, e)
+        }
+    }
+
+    // ==================== eSign Methods ====================
+
+    @ReactMethod
+    fun initializeESign(promise: Promise) {
+        Log.d(TAG, "▶️ initializeESign() called")
+        try {
+            val currentActivity = reactApplicationContext.currentActivity
+            if (currentActivity == null) {
+                Log.e(TAG, "❌ initializeESign() failed: Activity not available")
+                promise.reject("NO_ACTIVITY", "Activity not available")
+                return
+            }
+
+            SdkeSign.initializeESign(
+                context = currentActivity,
+                callbackSuccess = { code, message ->
+                    Log.d(TAG, "✅ initializeESign() success")
+                    val (eventMap, promiseMap) = createSeparateMaps { map ->
+                        map.putString("code", code.toString())
+                        map.putString("message", message)
+                    }
+                    sendEvent("onESignInitSuccess", eventMap)
+                    promise.resolve(promiseMap)
+                },
+                callbackError = { event, error ->
+                    Log.e(TAG, "❌ initializeESign() failed - Event: $event, Message: ${error.message}")
+                    val errorMap = Arguments.createMap().apply {
+                        putString("event", event.name.toString())
+                        putString("message", error.message)
+                        putString("code", error.code)
+                    }
+                    sendEvent("onESignError", errorMap)
+                    promise.reject(event.name.toString(), error.message)
+                }
+            )
+        } catch (e: Exception) {
+            Log.e(TAG, "❌ initializeESign() exception: ${e.message}", e)
+            promise.reject("ESIGN_EXCEPTION", e.message, e)
+        }
+    }
+
+    @ReactMethod
+    fun openSessionId(
+        accessToken: String?,
+        username: String?,
+        rememberMe: Boolean?,
+        userEsignModelJson: String?,
+        privateKeyFilePath: String?,
+        promise: Promise
+    ) {
+        Log.d(TAG, "▶️ openSessionId() called")
+        try {
+            val currentActivity = reactApplicationContext.currentActivity
+            if (currentActivity == null) {
+                Log.e(TAG, "❌ openSessionId() failed: Activity not available")
+                promise.reject("NO_ACTIVITY", "Activity not available")
+                return
+            }
+
+            if (accessToken != null && accessToken.isNotEmpty()) {
+                // Option 1: With existing JWT access token
+                SdkeSign.openSessionId(
+                    context = currentActivity,
+                    accessToken = accessToken,
+                    username = username ?: "",
+                    rememberMe = rememberMe ?: false,
+                    callbackSuccess = { deviceState, code, message ->
+                        Log.d(TAG, "✅ openSessionId() success")
+                        val (eventMap, promiseMap) = createSeparateMaps { map ->
+                            map.putString("deviceState", deviceState)
+                            map.putString("code", code.toString())
+                            map.putString("message", message)
+                        }
+                        sendEvent("onESignOpenSessionSuccess", eventMap)
+                        promise.resolve(promiseMap)
+                    },
+                    callbackError = { event, error ->
+                        Log.e(TAG, "❌ openSessionId() failed - Event: $event, Message: ${error.message}")
+                        val errorMap = Arguments.createMap().apply {
+                            putString("event", event.name.toString())
+                            putString("message", error.message)
+                            putString("code", error.code)
+                        }
+                        sendEvent("onESignError", errorMap)
+                        promise.reject(event.name.toString(), error.message)
+                    }
+                )
+            } else if (userEsignModelJson != null && privateKeyFilePath != null) {
+                // Option 2: Auto-create token from user info
+                val json = JSONObject(userEsignModelJson)
+                val userInfo = UserEsignModel(
+                    cccd = json.getString("cccd"),
+                    name = json.getString("name"),
+                    device = json.optString("device", "Android"),
+                    deviceId = json.optString("deviceId", android.provider.Settings.Secure.getString(
+                        reactApplicationContext.contentResolver,
+                        android.provider.Settings.Secure.ANDROID_ID
+                    ) ?: "")
+                )
+
+                SdkeSign.openSessionId(
+                    context = currentActivity,
+                    userEsignModel = userInfo,
+                    privateKeyFilePath = privateKeyFilePath,
+                    username = username ?: "",
+                    rememberMe = rememberMe ?: false,
+                    callbackSuccess = { deviceState, code, message ->
+                        Log.d(TAG, "✅ openSessionId() success")
+                        val (eventMap, promiseMap) = createSeparateMaps { map ->
+                            map.putString("deviceState", deviceState)
+                            map.putString("code", code.toString())
+                            map.putString("message", message)
+                        }
+                        sendEvent("onESignOpenSessionSuccess", eventMap)
+                        promise.resolve(promiseMap)
+                    },
+                    callbackError = { event, error ->
+                        Log.e(TAG, "❌ openSessionId() failed - Event: $event, Message: ${error.message}")
+                        val errorMap = Arguments.createMap().apply {
+                            putString("event", event.name.toString())
+                            putString("message", error.message)
+                            putString("code", error.code)
+                        }
+                        sendEvent("onESignError", errorMap)
+                        promise.reject(event.name.toString(), error.message)
+                    }
+                )
+            } else {
+                Log.e(TAG, "❌ openSessionId() failed: Invalid parameters")
+                promise.reject("INVALID_PARAMS", "Either accessToken or (userEsignModelJson + privateKeyFilePath) must be provided")
+            }
+        } catch (e: Exception) {
+            Log.e(TAG, "❌ openSessionId() exception: ${e.message}", e)
+            promise.reject("ESIGN_EXCEPTION", e.message, e)
+        }
+    }
+
+    @ReactMethod
+    fun registerDevice(
+        recoverCode: String,
+        pinCode: String,
+        fcmToken: String?,
+        promise: Promise
+    ) {
+        Log.d(TAG, "▶️ registerDevice() called")
+        try {
+            val currentActivity = reactApplicationContext.currentActivity
+            if (currentActivity == null) {
+                Log.e(TAG, "❌ registerDevice() failed: Activity not available")
+                promise.reject("NO_ACTIVITY", "Activity not available")
+                return
+            }
+
+            SdkeSign.registerDevice(
+                context = currentActivity,
+                recoverCode = recoverCode,
+                pinCode = pinCode,
+                fcmToken = fcmToken ?: "",
+                callbackSuccess = { code, message ->
+                    Log.d(TAG, "✅ registerDevice() success")
+                    val (eventMap, promiseMap) = createSeparateMaps { map ->
+                        map.putString("code", code.toString())
+                        map.putString("message", message)
+                    }
+                    sendEvent("onESignRegisterDeviceSuccess", eventMap)
+                    promise.resolve(promiseMap)
+                },
+                callbackError = { event, error ->
+                    Log.e(TAG, "❌ registerDevice() failed - Event: $event, Message: ${error.message}")
+                    val errorMap = Arguments.createMap().apply {
+                        putString("event", event.name.toString())
+                        putString("message", error.message)
+                        putString("code", error.code)
+                    }
+                    sendEvent("onESignError", errorMap)
+                    promise.reject(event.name.toString(), error.message)
+                }
+            )
+        } catch (e: Exception) {
+            Log.e(TAG, "❌ registerDevice() exception: ${e.message}", e)
+            promise.reject("ESIGN_EXCEPTION", e.message, e)
+        }
+    }
+
+    @ReactMethod
+    fun listCerts(
+        pageNumber: Int,
+        pageSize: Int,
+        promise: Promise
+    ) {
+        Log.d(TAG, "▶️ listCerts() called")
+        try {
+            val currentActivity = reactApplicationContext.currentActivity
+            if (currentActivity == null) {
+                Log.e(TAG, "❌ listCerts() failed: Activity not available")
+                promise.reject("NO_ACTIVITY", "Activity not available")
+                return
+            }
+
+            SdkeSign.listCerts(
+                context = currentActivity,
+                pageNumber = pageNumber,
+                pageSize = pageSize,
+                callbackSuccess = { certs ->
+                    Log.d(TAG, "✅ listCerts() success - Count: ${certs.size}")
+                    val (eventMap, promiseMap) = createSeparateMapsWithArray(
+                        arrayBuilder = { array: WritableArray ->
+                            certs.forEach { cert ->
+                                val certMap = Arguments.createMap().apply {
+                                    putString("serial", cert.serial)
+                                    putString("subject", cert.subject)
+                                    putString("validFrom", cert.validFrom)
+                                    putString("validTo", cert.validTo)
+                                }
+                                array.pushMap(certMap)
+                            }
+                        },
+                        mapBuilder = { map: WritableMap, array: WritableArray -> map.putArray("certs", array) }
+                    )
+                    sendEvent("onESignListCertsSuccess", eventMap)
+                    promise.resolve(promiseMap)
+                },
+                callbackError = { event, error ->
+                    Log.e(TAG, "❌ listCerts() failed - Event: $event, Message: ${error.message}")
+                    val errorMap = Arguments.createMap().apply {
+                        putString("event", event.name.toString())
+                        putString("message", error.message)
+                        putString("code", error.code)
+                    }
+                    sendEvent("onESignError", errorMap)
+                    promise.reject(event.name.toString(), error.message)
+                }
+            )
+        } catch (e: Exception) {
+            Log.e(TAG, "❌ listCerts() exception: ${e.message}", e)
+            promise.reject("ESIGN_EXCEPTION", e.message, e)
+        }
+    }
+
+    @ReactMethod
+    fun verifyCert(
+        serial: String,
+        promise: Promise
+    ) {
+        Log.d(TAG, "▶️ verifyCert() called")
+        try {
+            val currentActivity = reactApplicationContext.currentActivity
+            if (currentActivity == null) {
+                Log.e(TAG, "❌ verifyCert() failed: Activity not available")
+                promise.reject("NO_ACTIVITY", "Activity not available")
+                return
+            }
+
+            SdkeSign.verifyCert(
+                context = currentActivity,
+                serial = serial,
+                callbackSuccess = { code, message ->
+                    Log.d(TAG, "✅ verifyCert() success")
+                    val (eventMap, promiseMap) = createSeparateMaps { map ->
+                        map.putString("code", code.toString())
+                        map.putString("message", message)
+                    }
+                    sendEvent("onESignVerifyCertSuccess", eventMap)
+                    promise.resolve(promiseMap)
+                },
+                callbackError = { event, error ->
+                    Log.e(TAG, "❌ verifyCert() failed - Event: $event, Message: ${error.message}")
+                    val errorMap = Arguments.createMap().apply {
+                        putString("event", event.name.toString())
+                        putString("message", error.message)
+                        putString("code", error.code)
+                    }
+                    sendEvent("onESignError", errorMap)
+                    promise.reject(event.name.toString(), error.message)
+                }
+            )
+        } catch (e: Exception) {
+            Log.e(TAG, "❌ verifyCert() exception: ${e.message}", e)
+            promise.reject("ESIGN_EXCEPTION", e.message, e)
+        }
+    }
+
+    @ReactMethod
+    fun listSignRequest(
+        pageNumber: Int,
+        pageSize: Int,
+        promise: Promise
+    ) {
+        Log.d(TAG, "▶️ listSignRequest() called")
+        try {
+            val currentActivity = reactApplicationContext.currentActivity
+            if (currentActivity == null) {
+                Log.e(TAG, "❌ listSignRequest() failed: Activity not available")
+                promise.reject("NO_ACTIVITY", "Activity not available")
+                return
+            }
+
+            SdkeSign.listSignRequest(
+                context = currentActivity,
+                pageNumber = pageNumber,
+                pageSize = pageSize,
+                callbackSuccess = { requests ->
+                    Log.d(TAG, "✅ listSignRequest() success - Count: ${requests.size}")
+                    val (eventMap, promiseMap) = createSeparateMapsWithArray(
+                        arrayBuilder = { array: WritableArray ->
+                            requests.forEach { request ->
+                                val requestMap = Arguments.createMap().apply {
+                                    putString("requestId", request.requestId)
+                                    putString("documentName", request.documentName)
+                                    putString("status", request.status)
+                                }
+                                array.pushMap(requestMap)
+                            }
+                        },
+                        mapBuilder = { map: WritableMap, array: WritableArray -> map.putArray("requests", array) }
+                    )
+                    sendEvent("onESignListSignRequestSuccess", eventMap)
+                    promise.resolve(promiseMap)
+                },
+                callbackError = { event, error ->
+                    Log.e(TAG, "❌ listSignRequest() failed - Event: $event, Message: ${error.message}")
+                    val errorMap = Arguments.createMap().apply {
+                        putString("event", event.name.toString())
+                        putString("message", error.message)
+                        putString("code", error.code)
+                    }
+                    sendEvent("onESignError", errorMap)
+                    promise.reject(event.name.toString(), error.message)
+                }
+            )
+        } catch (e: Exception) {
+            Log.e(TAG, "❌ listSignRequest() exception: ${e.message}", e)
+            promise.reject("ESIGN_EXCEPTION", e.message, e)
+        }
+    }
+
+    @ReactMethod
+    fun confirmSign(
+        signRequestId: String,
+        pinCode: String,
+        authId: String?,
+        authData: String?,
+        confirm: Boolean,
+        promise: Promise
+    ) {
+        Log.d(TAG, "▶️ confirmSign() called")
+        try {
+            val currentActivity = reactApplicationContext.currentActivity
+            if (currentActivity == null) {
+                Log.e(TAG, "❌ confirmSign() failed: Activity not available")
+                promise.reject("NO_ACTIVITY", "Activity not available")
+                return
+            }
+
+            SdkeSign.confirmSign(
+                context = currentActivity,
+                signRequestId = signRequestId,
+                pinCode = pinCode,
+                authId = authId ?: "",
+                authData = authData ?: "",
+                confirm = confirm,
+                callbackSuccess = { code, message ->
+                    Log.d(TAG, "✅ confirmSign() success")
+                    val (eventMap, promiseMap) = createSeparateMaps { map ->
+                        map.putString("code", code.toString())
+                        map.putString("message", message)
+                    }
+                    sendEvent("onESignConfirmSignSuccess", eventMap)
+                    promise.resolve(promiseMap)
+                },
+                callbackError = { event, error ->
+                    Log.e(TAG, "❌ confirmSign() failed - Event: $event, Message: ${error.message}")
+                    val errorMap = Arguments.createMap().apply {
+                        putString("event", event.name.toString())
+                        putString("message", error.message)
+                        putString("code", error.code)
+                    }
+                    sendEvent("onESignError", errorMap)
+                    promise.reject(event.name.toString(), error.message)
+                }
+            )
+        } catch (e: Exception) {
+            Log.e(TAG, "❌ confirmSign() exception: ${e.message}", e)
+            promise.reject("ESIGN_EXCEPTION", e.message, e)
+        }
+    }
+
+    @ReactMethod
+    fun authenticate(
+        username: String,
+        password: String,
+        promise: Promise
+    ) {
+        Log.d(TAG, "▶️ authenticate() called")
+        try {
+            SdkeSign.authenticate(
+                username = username,
+                password = password,
+                callbackSuccess = { token, userId ->
+                    Log.d(TAG, "✅ authenticate() success")
+                    val (eventMap, promiseMap) = createSeparateMaps { map ->
+                        map.putString("token", token)
+                        map.putString("userId", userId.toString())
+                    }
+                    sendEvent("onESignAuthenticateSuccess", eventMap)
+                    promise.resolve(promiseMap)
+                },
+                callbackError = { event, error ->
+                    Log.e(TAG, "❌ authenticate() failed - Event: $event, Message: ${error.message}")
+                    val errorMap = Arguments.createMap().apply {
+                        putString("event", event.name.toString())
+                        putString("message", error.message)
+                        putString("code", error.code)
+                    }
+                    sendEvent("onESignError", errorMap)
+                    promise.reject(event.name.toString(), error.message)
+                }
+            )
+        } catch (e: Exception) {
+            Log.e(TAG, "❌ authenticate() exception: ${e.message}", e)
+            promise.reject("ESIGN_EXCEPTION", e.message, e)
+        }
+    }
+
+    @ReactMethod
+    fun registerRemoteSigning(
+        accessToken: String,
+        requestJson: String,
+        promise: Promise
+    ) {
+        Log.d(TAG, "▶️ registerRemoteSigning() called")
+        try {
+            SdkeSign.registerRemoteSigning(
+                accessToken = accessToken,
+                requestJson = requestJson,
+                callbackSuccess = { rawResponse ->
+                    Log.d(TAG, "✅ registerRemoteSigning() success")
+                    val (eventMap, promiseMap) = createSeparateMaps { map ->
+                        map.putString("response", rawResponse)
+                    }
+                    sendEvent("onESignRegisterRemoteSigningSuccess", eventMap)
+                    promise.resolve(promiseMap)
+                },
+                callbackError = { event, error ->
+                    Log.e(TAG, "❌ registerRemoteSigning() failed - Event: $event, Message: ${error.message}")
+                    val errorMap = Arguments.createMap().apply {
+                        putString("event", event.name.toString())
+                        putString("message", error.message)
+                        putString("code", error.code)
+                    }
+                    sendEvent("onESignError", errorMap)
+                    promise.reject(event.name.toString(), error.message)
+                }
+            )
+        } catch (e: Exception) {
+            Log.e(TAG, "❌ registerRemoteSigning() exception: ${e.message}", e)
+            promise.reject("ESIGN_EXCEPTION", e.message, e)
+        }
+    }
+
+    @ReactMethod
+    fun signPdf(
+        accessToken: String,
+        requestJson: String,
+        promise: Promise
+    ) {
+        Log.d(TAG, "▶️ signPdf() called")
+        try {
+            SdkeSign.signPdf(
+                accessToken = accessToken,
+                requestJson = requestJson,
+                callbackSuccess = { rawResponse ->
+                    Log.d(TAG, "✅ signPdf() success")
+                    val (eventMap, promiseMap) = createSeparateMaps { map ->
+                        map.putString("response", rawResponse)
+                    }
+                    sendEvent("onESignSignPdfSuccess", eventMap)
+                    promise.resolve(promiseMap)
+                },
+                callbackError = { event, error ->
+                    Log.e(TAG, "❌ signPdf() failed - Event: $event, Message: ${error.message}")
+                    val errorMap = Arguments.createMap().apply {
+                        putString("event", event.name.toString())
+                        putString("message", error.message)
+                        putString("code", error.code)
+                    }
+                    sendEvent("onESignError", errorMap)
+                    promise.reject(event.name.toString(), error.message)
+                }
+            )
+        } catch (e: Exception) {
+            Log.e(TAG, "❌ signPdf() exception: ${e.message}", e)
+            promise.reject("ESIGN_EXCEPTION", e.message, e)
+        }
+    }
+
+    @ReactMethod
+    fun sendConfirmationDocument(
+        accessToken: String,
+        requestJson: String,
+        promise: Promise
+    ) {
+        Log.d(TAG, "▶️ sendConfirmationDocument() called")
+        try {
+            SdkeSign.sendConfirmationDocument(
+                accessToken = accessToken,
+                requestJson = requestJson,
+                callbackSuccess = { rawResponse ->
+                    Log.d(TAG, "✅ sendConfirmationDocument() success")
+                    val (eventMap, promiseMap) = createSeparateMaps { map ->
+                        map.putString("response", rawResponse)
+                    }
+                    sendEvent("onESignSendConfirmationDocumentSuccess", eventMap)
+                    promise.resolve(promiseMap)
+                },
+                callbackError = { event, error ->
+                    Log.e(TAG, "❌ sendConfirmationDocument() failed - Event: $event, Message: ${error.message}")
+                    val errorMap = Arguments.createMap().apply {
+                        putString("event", event.name.toString())
+                        putString("message", error.message)
+                        putString("code", error.code)
+                    }
+                    sendEvent("onESignError", errorMap)
+                    promise.reject(event.name.toString(), error.message)
+                }
+            )
+        } catch (e: Exception) {
+            Log.e(TAG, "❌ sendConfirmationDocument() exception: ${e.message}", e)
+            promise.reject("ESIGN_EXCEPTION", e.message, e)
+        }
+    }
+
 }