@finos_sdk/sdk-ekyc 1.2.9 → 1.3.2

package/android/build.gradle

@@ -65,7 +65,7 @@ dependencies {
     implementation 'com.facebook.react:react-android'
 
     // Finos eKYC SDK dependencies from GitHub Packages Maven repository
-    def sdkVersion = "1.2.9"
+    def sdkVersion = "1.3.2"
     implementation("finos.sdk.ekyc:ekyc:$sdkVersion")
     implementation("finos.sdk.ekyc:ekycui:$sdkVersion")
     implementation("finos.sdk.ekyc:nfc:$sdkVersion")

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.ReadableArray
 import com.facebook.react.bridge.WritableArray
 import com.facebook.react.bridge.WritableMap
 import com.facebook.react.module.annotations.ReactModule
@@ -15,6 +16,7 @@ import com.facebook.react.modules.core.DeviceEventManagerModule
 import finos.sdk.c06.SdkEkycC06
 import finos.sdk.core.define.EKYCEvent
 import finos.sdk.core.define.SDKType
+import finos.sdk.core.define.SDKFaceDetectStatus
 import finos.sdk.core.model.response.SDKEkycResult
 import finos.sdk.core.model.sdk.config.AppKeyConfig
 import finos.sdk.core.model.sdk.config.C06Config
@@ -35,7 +37,7 @@ 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
@@ -330,10 +332,14 @@ class EKYCModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMo
     fun startLiveness(
         appKey: String,
         selfieImage: String,
-        usingRandomAction: Boolean,
         transactionId: String,
-        isStraight: Boolean,
         switchFrontCamera: Boolean?,
+        useActiveLiveness: Boolean?,
+        autoCapture: Boolean?,
+        isShowCameraFont: Boolean?,
+        customActionsArray: ReadableArray?,
+        activeActionCount: Int?,
+        forceCaptureTimeout: Double?,
         promise: Promise
     ) {
         Log.d(TAG, "▶️ startLiveness() called")
@@ -350,13 +356,38 @@ class EKYCModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMo
                 return
             }
 
+            // Parse customActions from ReadableArray
+            val customActions: List<SDKFaceDetectStatus>? = if (customActionsArray != null && customActionsArray.size() > 0) {
+                val actions = mutableListOf<SDKFaceDetectStatus>()
+                for (i in 0 until customActionsArray.size()) {
+                    val actionString = customActionsArray.getString(i)
+                    when (actionString) {
+                        "LEFT" -> actions.add(SDKFaceDetectStatus.LEFT)
+                        "RIGHT" -> actions.add(SDKFaceDetectStatus.RIGHT)
+                        "STRAIGHT" -> actions.add(SDKFaceDetectStatus.STRAIGHT)
+                        else -> Log.w(TAG, "Unknown action: $actionString")
+                    }
+                }
+                if (actions.isNotEmpty()) actions else null
+            } else {
+                null
+            }
+
             val livenessConfig =
                 LivenessConfig(
+                    isActiveLiveness = useActiveLiveness ?: false,
+                    autoCapture = autoCapture ?: true,
+                    isShowCameraFont = isShowCameraFont ?: (switchFrontCamera ?: true),
+                    // Custom actions từ checkboxes (nếu có chọn)
+                    // Nếu có actions được chọn → sử dụng customActions
+                    // Nếu không có actions nào được chọn → sử dụng random actions với activeActionCount
+                    customActions = customActions,
+                    // Number of random actions (1-10), only used when customActions = null
+                    // activeActionCount = 2 → 2 random actions + STRAIGHT
+                    activeActionCount = activeActionCount ?: 2,
+                    forceCaptureTimeout = (forceCaptureTimeout ?: 0.0).toLong(),
                     selfieImage = imageFile,
-                    usingRandomAction = usingRandomAction,
-                    isStraight = isStraight,
-                    transactionId = transactionId,
-                    isShowCameraFont = switchFrontCamera ?: false
+                    transactionId = transactionId
                 )
             val ekycConfig =
                 EKYCConfigSDK(
@@ -965,8 +996,8 @@ class EKYCModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMo
     // ==================== eSign Methods ====================
 
     @ReactMethod
-    fun initializeESign(promise: Promise) {
-        Log.d(TAG, "▶️ initializeESign() called")
+    fun initializeESign(finosToken: String?, promise: Promise) {
+        Log.d(TAG, "▶️ initializeESign() called with token: ${finosToken?.take(10)}...")
         try {
             val currentActivity = reactApplicationContext.currentActivity
             if (currentActivity == null) {
@@ -977,6 +1008,7 @@ class EKYCModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMo
 
             SdkeSign.initializeESign(
                 context = currentActivity,
+                finosToken = finosToken,
                 callbackSuccess = { code, message ->
                     Log.d(TAG, "✅ initializeESign() success")
                     val (eventMap, promiseMap) = createSeparateMaps { map ->
@@ -990,11 +1022,11 @@ class EKYCModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMo
                     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)
+                        putString("message", error.message ?: "")
+                        putString("code", error.code.toString())
                     }
                     sendEvent("onESignError", errorMap)
-                    promise.reject(event.name.toString(), error.message)
+                    promise.reject(event.name.toString(), error.message ?: "Unknown Error")
                 }
             )
         } catch (e: Exception) {
@@ -1003,13 +1035,40 @@ class EKYCModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMo
         }
     }
 
+    @ReactMethod
+    fun getSdkToken(
+        identity: String,
+        name: String,
+        deviceId: String,
+        promise: Promise
+    ) {
+        Log.d(TAG, "▶️ getSdkToken() called")
+        try {
+            SdkeSign.getSdkToken(
+                cccd = identity, // Map identity param to cccd
+                name = name,
+                deviceId = deviceId,
+                callbackSuccess = { token ->
+                    Log.d(TAG, "✅ getSdkToken() success")
+                    promise.resolve(token)
+                },
+                callbackError = { event, error ->
+                    Log.e(TAG, "❌ getSdkToken() failed: $error")
+                    // error might be String or Object, toString() covers both
+                    promise.reject("GET_SDK_TOKEN_ERROR", error.toString())
+                }
+            )
+        } catch (e: Exception) {
+            Log.e(TAG, "❌ getSdkToken() 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")
@@ -1042,56 +1101,16 @@ class EKYCModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMo
                         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)
+                            putString("message", error.message ?: "")
+                            putString("code", error.code.toString())
                         }
                         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)
+                        promise.reject(event.name.toString(), error.message ?: "Unknown Error")
                     }
                 )
             } else {
                 Log.e(TAG, "❌ openSessionId() failed: Invalid parameters")
-                promise.reject("INVALID_PARAMS", "Either accessToken or (userEsignModelJson + privateKeyFilePath) must be provided")
+                promise.reject("INVALID_PARAMS", "accessToken must be provided")
             }
         } catch (e: Exception) {
             Log.e(TAG, "❌ openSessionId() exception: ${e.message}", e)
@@ -1133,11 +1152,11 @@ class EKYCModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMo
                     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)
+                        putString("message", error.message ?: "")
+                        putString("code", error.code.toString())
                     }
                     sendEvent("onESignError", errorMap)
-                    promise.reject(event.name.toString(), error.message)
+                    promise.reject(event.name.toString(), error.message ?: "Unknown Error")
                 }
             )
         } catch (e: Exception) {
@@ -1156,7 +1175,6 @@ class EKYCModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMo
         try {
             val currentActivity = reactApplicationContext.currentActivity
             if (currentActivity == null) {
-                Log.e(TAG, "❌ listCerts() failed: Activity not available")
                 promise.reject("NO_ACTIVITY", "Activity not available")
                 return
             }
@@ -1166,7 +1184,7 @@ class EKYCModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMo
                 pageNumber = pageNumber,
                 pageSize = pageSize,
                 callbackSuccess = { certs ->
-                    Log.d(TAG, "✅ listCerts() success - Count: ${certs.size}")
+                    // Bắn raw data lên - để EKYCModule.ts xử lý
                     val (eventMap, promiseMap) = createSeparateMapsWithArray(
                         arrayBuilder = { array: WritableArray ->
                             certs.forEach { cert ->
@@ -1185,18 +1203,17 @@ class EKYCModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMo
                     promise.resolve(promiseMap)
                 },
                 callbackError = { event, error ->
-                    Log.e(TAG, "❌ listCerts() failed - Event: $event, Message: ${error.message}")
+                    // Bắn raw data lên - để EKYCModule.ts xử lý
                     val errorMap = Arguments.createMap().apply {
                         putString("event", event.name.toString())
-                        putString("message", error.message)
-                        putString("code", error.code)
+                        putString("message", error.message ?: "")
+                        putString("code", error.code.toString())
                     }
                     sendEvent("onESignError", errorMap)
-                    promise.reject(event.name.toString(), error.message)
+                    promise.reject(event.name.toString(), error.message ?: "Unknown Error")
                 }
             )
         } catch (e: Exception) {
-            Log.e(TAG, "❌ listCerts() exception: ${e.message}", e)
             promise.reject("ESIGN_EXCEPTION", e.message, e)
         }
     }
@@ -1207,10 +1224,22 @@ class EKYCModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMo
         promise: Promise
     ) {
         Log.d(TAG, "▶️ verifyCert() called")
+        
+        if (serial.isBlank()) {
+            val errorMsg = "Certificate serial không được để trống"
+            val errorMap = Arguments.createMap().apply {
+                putString("event", "SDK_START_ERROR")
+                putString("message", errorMsg)
+                putString("code", "INVALID_SERIAL")
+            }
+            sendEvent("onESignError", errorMap)
+            promise.reject("INVALID_SERIAL", errorMsg)
+            return
+        }
+        
         try {
             val currentActivity = reactApplicationContext.currentActivity
             if (currentActivity == null) {
-                Log.e(TAG, "❌ verifyCert() failed: Activity not available")
                 promise.reject("NO_ACTIVITY", "Activity not available")
                 return
             }
@@ -1219,7 +1248,7 @@ class EKYCModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMo
                 context = currentActivity,
                 serial = serial,
                 callbackSuccess = { code, message ->
-                    Log.d(TAG, "✅ verifyCert() success")
+                    // Bắn raw data lên - để EKYCModule.ts xử lý
                     val (eventMap, promiseMap) = createSeparateMaps { map ->
                         map.putString("code", code.toString())
                         map.putString("message", message)
@@ -1228,18 +1257,19 @@ class EKYCModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMo
                     promise.resolve(promiseMap)
                 },
                 callbackError = { event, error ->
-                    Log.e(TAG, "❌ verifyCert() failed - Event: $event, Message: ${error.message}")
+                    // Bắn raw data lên - để EKYCModule.ts xử lý
+                    val errorMessage = error.message ?: ""
+                    val errorCode = error.code.toString()
                     val errorMap = Arguments.createMap().apply {
                         putString("event", event.name.toString())
-                        putString("message", error.message)
-                        putString("code", error.code)
+                        putString("message", errorMessage)
+                        putString("code", errorCode)
                     }
                     sendEvent("onESignError", errorMap)
-                    promise.reject(event.name.toString(), error.message)
+                    promise.reject(event.name.toString(), errorMessage)
                 }
             )
         } catch (e: Exception) {
-            Log.e(TAG, "❌ verifyCert() exception: ${e.message}", e)
             promise.reject("ESIGN_EXCEPTION", e.message, e)
         }
     }
@@ -1254,7 +1284,6 @@ class EKYCModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMo
         try {
             val currentActivity = reactApplicationContext.currentActivity
             if (currentActivity == null) {
-                Log.e(TAG, "❌ listSignRequest() failed: Activity not available")
                 promise.reject("NO_ACTIVITY", "Activity not available")
                 return
             }
@@ -1264,14 +1293,16 @@ class EKYCModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMo
                 pageNumber = pageNumber,
                 pageSize = pageSize,
                 callbackSuccess = { requests ->
-                    Log.d(TAG, "✅ listSignRequest() success - Count: ${requests.size}")
+                    // Bắn raw data lên - để EKYCModule.ts xử lý
                     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)
+                                    putString("authId", request.authId ?: "")
+                                    putString("authData", request.authData ?: "")
+                                    putString("status", request.authId ?: "")
+                                    putString("documentName", request.authData ?: "")
                                 }
                                 array.pushMap(requestMap)
                             }
@@ -1282,18 +1313,17 @@ class EKYCModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMo
                     promise.resolve(promiseMap)
                 },
                 callbackError = { event, error ->
-                    Log.e(TAG, "❌ listSignRequest() failed - Event: $event, Message: ${error.message}")
+                    // Bắn raw data lên - để EKYCModule.ts xử lý
                     val errorMap = Arguments.createMap().apply {
                         putString("event", event.name.toString())
-                        putString("message", error.message)
-                        putString("code", error.code)
+                        putString("message", error.message ?: "")
+                        putString("code", error.code.toString())
                     }
                     sendEvent("onESignError", errorMap)
-                    promise.reject(event.name.toString(), error.message)
+                    promise.reject(event.name.toString(), error.message ?: "Unknown Error")
                 }
             )
         } catch (e: Exception) {
-            Log.e(TAG, "❌ listSignRequest() exception: ${e.message}", e)
             promise.reject("ESIGN_EXCEPTION", e.message, e)
         }
     }
@@ -1308,6 +1338,8 @@ class EKYCModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMo
         promise: Promise
     ) {
         Log.d(TAG, "▶️ confirmSign() called")
+        Log.d(TAG, "   📋 Request params - signRequestId: $signRequestId, confirm: $confirm")
+        Log.d(TAG, "   📋 Auth params - authId: ${authId?.take(20)}..., authData: ${authData?.take(20)}...")
         try {
             val currentActivity = reactApplicationContext.currentActivity
             if (currentActivity == null) {
@@ -1316,6 +1348,7 @@ class EKYCModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMo
                 return
             }
 
+            Log.d(TAG, "   🔄 Calling SdkeSign.confirmSign()")
             SdkeSign.confirmSign(
                 context = currentActivity,
                 signRequestId = signRequestId,
@@ -1324,7 +1357,8 @@ class EKYCModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMo
                 authData = authData ?: "",
                 confirm = confirm,
                 callbackSuccess = { code, message ->
-                    Log.d(TAG, "✅ confirmSign() success")
+                    Log.d(TAG, "✅ confirmSign() success - Code: $code, Message: $message")
+                    // Bắn raw data lên - để EKYCModule.ts xử lý
                     val (eventMap, promiseMap) = createSeparateMaps { map ->
                         map.putString("code", code.toString())
                         map.putString("message", message)
@@ -1333,69 +1367,47 @@ class EKYCModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMo
                     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)
+                    val errorMessage = error.message ?: ""
+                    val errorCode = error.code.toString()
+                    
+                    Log.d(TAG, "🔍 confirmSign() error callback - Message: '$errorMessage', Code: '$errorCode'")
+                    
+                    // Check if message contains "thành công" or code == "0" -> treat as success
+                    if (errorMessage.contains("thành công", ignoreCase = true) || errorCode == "0") {
+                        Log.d(TAG, "✅ confirmSign() success (async operation) - Message: $errorMessage")
+                        val (eventMap, promiseMap) = createSeparateMaps { map ->
+                            map.putString("code", "200")
+                            map.putString("message", errorMessage)
+                        }
+                        sendEvent("onESignConfirmSignSuccess", eventMap)
+                        promise.resolve(promiseMap)
+                    } else {
+                        Log.e(TAG, "❌ confirmSign() failed - Event: $event, Message: $errorMessage, Code: $errorCode")
+                        val errorMap = Arguments.createMap().apply {
+                            putString("event", event.name.toString())
+                            putString("message", errorMessage)
+                            putString("code", errorCode)
+                        }
+                        sendEvent("onESignError", errorMap)
+                        promise.reject(event.name.toString(), errorMessage)
                     }
-                    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")
@@ -1406,14 +1418,28 @@ class EKYCModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMo
                     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)
+                    val errorMessage = error.message ?: ""
+                    val errorCode = error.code.toString()
+                    
+                    // Check if message contains "thành công" or code == "0" -> treat as success
+                    if (errorMessage.contains("thành công", ignoreCase = true) || errorCode == "0") {
+                        Log.d(TAG, "✅ registerRemoteSigning() success (async operation) - Message: $errorMessage")
+                        val (eventMap, promiseMap) = createSeparateMaps { map ->
+                            map.putString("response", "{\"status\":1,\"msg\":\"$errorMessage\"}")
+                            map.putString("message", errorMessage)
+                        }
+                        sendEvent("onESignRegisterRemoteSigningSuccess", eventMap)
+                        promise.resolve(promiseMap)
+                    } else {
+                        Log.e(TAG, "❌ registerRemoteSigning() failed - Event: $event, Message: $errorMessage")
+                        val errorMap = Arguments.createMap().apply {
+                            putString("event", event.name.toString())
+                            putString("message", errorMessage)
+                            putString("code", errorCode)
+                        }
+                        sendEvent("onESignError", errorMap)
+                        promise.reject(event.name.toString(), errorMessage)
                     }
-                    sendEvent("onESignError", errorMap)
-                    promise.reject(event.name.toString(), error.message)
                 }
             )
         } catch (e: Exception) {
@@ -1424,17 +1450,15 @@ class EKYCModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMo
 
     @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")
+                    // Bắn raw data lên - để EKYCModule.ts xử lý
                     val (eventMap, promiseMap) = createSeparateMaps { map ->
                         map.putString("response", rawResponse)
                     }
@@ -1442,35 +1466,45 @@ class EKYCModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMo
                     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)
+                    val errorMessage = error.message ?: ""
+                    val errorCode = error.code.toString()
+                    
+                    // Check if message contains "thành công" or code == "0" -> treat as success
+                    if (errorMessage.contains("thành công", ignoreCase = true) || errorCode == "0") {
+                        Log.d(TAG, "✅ signPdf() success (async operation) - Message: $errorMessage")
+                        val (eventMap, promiseMap) = createSeparateMaps { map ->
+                            map.putString("response", "{\"status\":1,\"msg\":\"$errorMessage\"}")
+                            map.putString("message", errorMessage)
+                        }
+                        sendEvent("onESignSignPdfSuccess", eventMap)
+                        promise.resolve(promiseMap)
+                    } else {
+                        val errorMap = Arguments.createMap().apply {
+                            putString("event", event.name.toString())
+                            putString("message", errorMessage)
+                            putString("code", errorCode)
+                        }
+                        sendEvent("onESignError", errorMap)
+                        promise.reject(event.name.toString(), errorMessage)
                     }
-                    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")
+                    // Bắn raw data lên - để EKYCModule.ts xử lý
                     val (eventMap, promiseMap) = createSeparateMaps { map ->
                         map.putString("response", rawResponse)
                     }
@@ -1478,18 +1512,30 @@ class EKYCModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMo
                     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)
+                    val errorMessage = error.message ?: ""
+                    val errorCode = error.code.toString()
+                    
+                    // Check if message contains "thành công" or code == "0" -> treat as success
+                    if (errorMessage.contains("thành công", ignoreCase = true) || errorCode == "0") {
+                        Log.d(TAG, "✅ sendConfirmationDocument() success (async operation) - Message: $errorMessage")
+                        val (eventMap, promiseMap) = createSeparateMaps { map ->
+                            map.putString("response", "{\"status\":1,\"msg\":\"$errorMessage\"}")
+                            map.putString("message", errorMessage)
+                        }
+                        sendEvent("onESignSendConfirmationDocumentSuccess", eventMap)
+                        promise.resolve(promiseMap)
+                    } else {
+                        val errorMap = Arguments.createMap().apply {
+                            putString("event", event.name.toString())
+                            putString("message", errorMessage)
+                            putString("code", errorCode)
+                        }
+                        sendEvent("onESignError", errorMap)
+                        promise.reject(event.name.toString(), errorMessage)
                     }
-                    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)
         }
     }