@finos_sdk/sdk-ekyc 1.3.2 → 1.3.4

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.3.2"
+    def sdkVersion = "1.3.3.1"
     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

@@ -1,6 +1,9 @@
 package finos.sdk.ekyc
 
 import android.R
+import android.net.Uri
+import android.os.Handler
+import android.os.Looper
 import android.util.Base64
 import android.util.Log
 import com.facebook.react.bridge.Arguments
@@ -38,9 +41,12 @@ import finos.sdk.smsotp.SdkSmsOtpService
 import finos.sdk.core.model.sdk.config.SmsOtpConfig
 import vn.softdreams.easyca.sdk.SdkeSign
 
+import org.json.JSONArray
 import org.json.JSONObject
 import java.io.File
 import java.io.FileOutputStream
+import java.io.FileInputStream
+import java.io.InputStream
 import java.util.Date
 
 @ReactModule(name = EKYCModule.NAME)
@@ -102,8 +108,20 @@ class EKYCModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMo
                 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}")
+            val msg = e.message?.lowercase() ?: ""
+            // SDK đã được khởi tạo (Koin/DI already started) → coi là thành công, cho icon pass xanh / text xanh
+            if (msg.contains("already been started") || msg.contains("already started") || msg.contains("already initialized")) {
+                Log.d(TAG, "✅ initSdkEkyc() – SDK đã khởi tạo, trả success (không coi là lỗi)")
+                val params = Arguments.createMap().apply {
+                    putString("status", "success")
+                    putString("message", "SDK EKYC already initialized")
+                }
+                sendEvent("EKYCInitEvent", params)
+                promise.resolve(true)
+            } else {
+                Log.e(TAG, "❌ initSdkEkyc() failed: ${e.message}", e)
+                promise.reject("INIT_ERROR", "Failed to initialize SDK EKYC: ${e.message}")
+            }
         }
     }
 
@@ -433,48 +451,58 @@ class EKYCModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMo
     ) {
         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")
+            // React Native có thể gọi khi currentActivity = null (background / app state).
+            // FaceService không cần Activity, nên không block ở đây.
+            val selfieFile = resolveImageInputToFile(selfieImage, "selfie")
+            val idImageFile = resolveImageInputToFile(idImage, "id")
+
+            if (!selfieFile.exists() || selfieFile.length() <= 0L) {
+                promise.reject("SELFIE_IMAGE_INVALID", "Selfie image is invalid or not found")
                 return
             }
-            val imageFile = File(selfieImage.replace("file://", ""))
-            if (!imageFile.exists()) {
-                promise.reject("FILE_NOT_FOUND", "Image file does not exist")
+            if (!idImageFile.exists() || idImageFile.length() <= 0L) {
+                promise.reject("ID_IMAGE_INVALID", "ID image is invalid or not found")
                 return
             }
-            val idImageFile = base64ToImageFile(idImage)
 
             val faceServiceConfig =
                 FaceServiceConfig(
                     transactionId = transactionId,
-                    selfieImage = imageFile,
+                    selfieImage = selfieFile,
                     idImage = idImageFile
                 )
-            val ekycConfig = EKYCConfigSDK(faceServiceConfig = faceServiceConfig)
-            SdkEkycFaceService.startEkyc(
-                ekycConfigSDK = ekycConfig,
-                callbackSuccess = { event, data ->
-                    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, "❌ startFaceCompare() failed - Event: $event, Message: $message")
-                    val errorMap =
-                        Arguments.createMap().apply {
-                            putString("event", event.name.toString())
-                            putString("message", message?.toString() ?: "Unknown error")
-                        }
-                    sendEvent("onFaceCompareError", errorMap)
-                    promise.reject(event.name.toString(), message?.toString() ?: "Unknown FaceService error")
-                }
+            // FaceService cần appKeyFaceService. Trước đây RN chỉ truyền 1 key string,
+            // nên map key này vào appKeyFaceService (và set appKey luôn để tương thích).
+            val ekycConfig = EKYCConfigSDK(
+                appKey = AppKeyConfig(appKey = appKey, appKeyFaceService = appKey),
+                faceServiceConfig = faceServiceConfig
             )
+
+            // Đảm bảo chạy trên main thread để tránh crash trên một số devices/SDK versions.
+            Handler(Looper.getMainLooper()).post {
+                SdkEkycFaceService.startEkyc(
+                    ekycConfigSDK = ekycConfig,
+                    callbackSuccess = { event, data ->
+                        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, "❌ startFaceCompare() failed - Event: $event, Message: $message")
+                        val errorMap =
+                            Arguments.createMap().apply {
+                                putString("event", event.name.toString())
+                                putString("message", message?.toString() ?: "Unknown error")
+                            }
+                        sendEvent("onFaceCompareError", errorMap)
+                        promise.reject(event.name.toString(), message?.toString() ?: "Unknown FaceService error")
+                    }
+                )
+            }
         } catch (e: Exception) {
             Log.e(TAG, "❌ startFaceCompare() exception: ${e.message}", e)
             promise.reject("FACE_COMPARE_ERROR", e.message)
@@ -502,7 +530,56 @@ class EKYCModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMo
         }
     }
 
-    private fun base64ToImageFile(base64Image: String): File {
+    /**
+     * Resolve input image string to a local file.
+     * - Supports: file path (`/...`), file URI (`file://...`), content URI (`content://...`), base64 (with/without data URI).
+     */
+    private fun resolveImageInputToFile(input: String, prefix: String): File {
+        val value = input.trim()
+        if (value.isEmpty()) {
+            // Return empty file to trigger validation error upstream
+            return File(reactApplicationContext.cacheDir, "empty_${prefix}_${Date().time}.jpg").apply {
+                createNewFile()
+            }
+        }
+
+        // file://...
+        if (value.startsWith("file://")) {
+            val file = File(value.removePrefix("file://"))
+            if (file.exists()) return file
+        }
+
+        // content://...
+        if (value.startsWith("content://")) {
+            val copied = copyContentUriToCacheFile(value, prefix)
+            if (copied != null && copied.exists()) return copied
+        }
+
+        // raw path
+        val rawFile = File(value)
+        if (rawFile.exists()) return rawFile
+
+        // fallback: treat as base64
+        return base64ToImageFile(value, prefix)
+    }
+
+    private fun copyContentUriToCacheFile(uriString: String, prefix: String): File? {
+        return try {
+            val uri = Uri.parse(uriString)
+            val resolver = reactApplicationContext.contentResolver
+            val inputStream: InputStream = resolver.openInputStream(uri) ?: return null
+            val outFile = File(reactApplicationContext.cacheDir, "${prefix}_${Date().time}.jpg")
+            FileOutputStream(outFile).use { out ->
+                inputStream.use { ins -> ins.copyTo(out) }
+            }
+            outFile
+        } catch (e: Exception) {
+            Log.w(TAG, "copyContentUriToCacheFile failed: ${e.message}")
+            null
+        }
+    }
+
+    private fun base64ToImageFile(base64Image: String, prefix: String = "image"): File {
         try {
             // Remove data URI prefix if present (like "data:image/png;base64,")
             var processedBase64 = base64Image
@@ -515,7 +592,7 @@ class EKYCModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMo
 
             // Create a unique filename with timestamp
             val timestamp = Date().time.toString()
-            val fileName = "image_$timestamp.jpg"
+            val fileName = "${prefix}_$timestamp.jpg"
 
             // Get temporary directory and create file path
             val directory = reactApplicationContext.cacheDir
@@ -527,14 +604,28 @@ class EKYCModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMo
 
             return imageFile
         } catch (e: Exception) {
-            Log.e("LivenessFragment", "Error converting base64 to image file: ${e.message}", e)
+            Log.e(TAG, "Error converting base64 to image file: ${e.message}", e)
             // In case of error, create an empty file to avoid null returns
-            val errorFile = File(reactApplicationContext.cacheDir, "error_image_${Date().time}.jpg")
+            val errorFile = File(reactApplicationContext.cacheDir, "error_${prefix}_${Date().time}.jpg")
             errorFile.createNewFile()
             return errorFile
         }
     }
 
+    /**
+     * Convert File to base64 string for passing to React Native.
+     * Mirrors Android SDK: data?.ekycStateModel?.eKYCFileModel?.imageFace
+     */
+    private fun fileToBase64(file: File?): String? {
+        if (file == null || !file.exists()) return null
+        return try {
+            Base64.encodeToString(file.readBytes(), Base64.NO_WRAP)
+        } catch (e: Exception) {
+            Log.e(TAG, "fileToBase64 error: ${e.message}", e)
+            null
+        }
+    }
+
     @ReactMethod
     fun startEkycUI(
         appKey: String,
@@ -574,15 +665,26 @@ class EKYCModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMo
             // Parse StyleConfig JSON from React Native
             val styleConfig = parseStyleConfig(styleConfigJson)
 
-            // Extract switchFrontCamera from optionConfigJson
+            // LivenessConfig theo SDKeKYCActivity (157-169): isActiveLiveness, autoCapture, forceCaptureTimeout, isShowCameraFont, customActions, activeActionCount
             val switchFrontCamera = extractBooleanValue(optionConfigJson, "switchFrontCamera") ?: false
+            val isActiveLiveness = extractBooleanValue(optionConfigJson, "isActiveLiveness") ?: true
+            val autoCapture = extractBooleanValue(optionConfigJson, "autoCapture") ?: true
+            val forceCaptureTimeoutSec = extractIntValue(optionConfigJson, "forceCaptureTimeout") ?: 30
+            val customActionsList = parseCustomActionsFromJson(optionConfigJson)
+            val activeActionCount = extractIntValue(optionConfigJson, "activeActionCount") ?: customActionsList?.size ?: 2
 
-            // Create LivenessConfig if LIVENESS is in the flow and switchFrontCamera is set
-            val livenessConfig = if (finalFlow.contains(SDKType.LIVENESS) && switchFrontCamera) {
-                LivenessConfig(isShowCameraFont = true)
+            val livenessConfig = if (finalFlow.contains(SDKType.LIVENESS)) {
+                LivenessConfig(
+                    isActiveLiveness = isActiveLiveness,
+                    autoCapture = autoCapture,
+                    forceCaptureTimeout = (forceCaptureTimeoutSec * 1000L).coerceAtLeast(0),
+                    isShowCameraFont = switchFrontCamera,
+                    customActions = customActionsList?.takeIf { it.isNotEmpty() },
+                    activeActionCount = activeActionCount,
+                )
             } else null
 
-            // Create EKYCConfigSDK like MainActivity.kt
+            // Create EKYCConfigSDK like SDKeKYCActivity / MainActivity.kt
             val ekycConfigSDK = EKYCConfigSDK(
                 appKey = appKeyConfig,
                 optionConfig = optionConfig.copy(language = if (language == "en") "en" else "vi"),
@@ -596,14 +698,31 @@ class EKYCModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMo
                 activity = currentActivity,
                 ekycConfigSDK = ekycConfigSDK,
                 callbackSuccess = { event, data ->
-                    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())
+                    Log.d(TAG, "✅ startEkycUI() callback - event=${event.name}")
+                    val result = data as? SDKEkycResult
+                    val hasRealData = result?.ekycStateModel != null
+                    // Chỉ resolve promise khi flow hoàn thành có data (SDK_END_SUCCESS); SDK_START_SUCCESS = activity vừa mở, bỏ qua
+                    if (event == EKYCEvent.SDK_START_SUCCESS && !hasRealData) {
+                        Log.d(TAG, "⏳ startEkycUI() SDK_START_SUCCESS – chờ SDK_END_SUCCESS")
+                        sendEvent("onEkycUISuccess", Arguments.createMap().apply {
+                            putString("status", "started")
+                            putString("event", event.name.toString())
+                        })
+                    } else {
+                        val ekycFiles = result?.ekycStateModel?.eKYCFileModel
+                        val ekycTransactionId = result?.ekycStateModel?.transactionId ?: ""
+                        val (eventMap, promiseMap) = createSeparateMaps { map ->
+                            map.putString("status", "success")
+                            map.putString("event", event.name.toString())
+                            map.putString("data", data.toString())
+                            map.putString("transactionId", ekycTransactionId)
+                            ekycFiles?.imageFace?.absolutePath?.let { map.putString("imageFacePath", it) }
+                            ekycFiles?.imageOcrFront?.absolutePath?.let { map.putString("imageOcrFrontPath", it) }
+                            ekycFiles?.imageOcrBack?.absolutePath?.let { map.putString("imageOcrBackPath", it) }
+                        }
+                        sendEvent("onEkycUISuccess", eventMap)
+                        promise.resolve(promiseMap)
                     }
-                    sendEvent("onEkycUISuccess", eventMap)
-                    promise.resolve(promiseMap)
                 },
                 callbackError = { event, errorResult ->
                     Log.e(TAG, "❌ startEkycUI() failed - Event: $event, Message: ${errorResult.message}")
@@ -703,6 +822,37 @@ class EKYCModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMo
         }
     }
 
+    /** Parse customActions array from optionConfig JSON. Maps như SDKeKYCActivity getSelectedCustomActions. */
+    private fun parseCustomActionsFromJson(optionConfigJson: String): List<SDKFaceDetectStatus>? {
+        return try {
+            val obj = JSONObject(optionConfigJson)
+            val arr = obj.optJSONArray("customActions") ?: return null
+            if (arr.length() == 0) return null
+            val actions = mutableListOf<SDKFaceDetectStatus>()
+            for (i in 0 until arr.length()) {
+                val s = arr.optString(i, "")
+                when (s) {
+                    "LEFT" -> actions.add(SDKFaceDetectStatus.LEFT)
+                    "RIGHT" -> actions.add(SDKFaceDetectStatus.RIGHT)
+                    "UP" -> actions.add(SDKFaceDetectStatus.UP)
+                    "DOWN" -> actions.add(SDKFaceDetectStatus.DOWN)
+                    "SMILE" -> actions.add(SDKFaceDetectStatus.SMILE)
+                    "BLINK" -> actions.add(SDKFaceDetectStatus.BLINK)
+                    "TILT_LEFT" -> actions.add(SDKFaceDetectStatus.TILT_LEFT)
+                    "TILT_RIGHT" -> actions.add(SDKFaceDetectStatus.TILT_RIGHT)
+                    "WINK_LEFT" -> actions.add(SDKFaceDetectStatus.WINK_LEFT)
+                    "WINK_RIGHT" -> actions.add(SDKFaceDetectStatus.WINK_RIGHT)
+                    "STRAIGHT" -> actions.add(SDKFaceDetectStatus.STRAIGHT)
+                    else -> if (s.isNotEmpty()) Log.w(TAG, "parseCustomActionsFromJson: unknown action=$s")
+                }
+            }
+            if (actions.isNotEmpty()) actions else null
+        } catch (e: Exception) {
+            Log.w(TAG, "parseCustomActionsFromJson: ${e.message}")
+            null
+        }
+    }
+
     private fun parseAppKeyConfig(appKeyConfigJson: String): AppKeyConfig {
         return try {
             if (appKeyConfigJson.isBlank() || appKeyConfigJson == "{}") {
@@ -1019,14 +1169,26 @@ class EKYCModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMo
                     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.toString())
+                    val msg = (error.message ?: "").lowercase()
+                    // eSign đã được khởi tạo → coi là thành công, cho icon pass xanh / text xanh
+                    if (msg.contains("đã được khởi tạo") || msg.contains("already") || msg.contains("already initialized")) {
+                        Log.d(TAG, "✅ initializeESign() – eSign đã khởi tạo, trả success (không coi là lỗi)")
+                        val (eventMap, promiseMap) = createSeparateMaps { map ->
+                            map.putString("code", "0")
+                            map.putString("message", "eSign already initialized")
+                        }
+                        sendEvent("onESignInitSuccess", eventMap)
+                        promise.resolve(promiseMap)
+                    } else {
+                        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.toString())
+                        }
+                        sendEvent("onESignError", errorMap)
+                        promise.reject(event.name.toString(), error.message ?: "Unknown Error")
                     }
-                    sendEvent("onESignError", errorMap)
-                    promise.reject(event.name.toString(), error.message ?: "Unknown Error")
                 }
             )
         } catch (e: Exception) {
@@ -1053,9 +1215,14 @@ class EKYCModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMo
                     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())
+                    Log.e(TAG, "❌ getSdkToken() failed - Event: $event, Message: ${error.message}")
+                    val errorMap = Arguments.createMap().apply {
+                        putString("event", event.name.toString())
+                        putString("message", error.message ?: "")
+                        putString("code", error.code.toString())
+                    }
+                    sendEvent("onESignError", errorMap)
+                    promise.reject(event.name.toString(), error.message ?: "Get SDK Token failed")
                 }
             )
         } catch (e: Exception) {
@@ -1420,26 +1587,14 @@ class EKYCModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMo
                 callbackError = { event, error ->
                     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)
+                    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)
                 }
             )
         } catch (e: Exception) {
@@ -1448,6 +1603,48 @@ class EKYCModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMo
         }
     }
 
+    /**
+     * Composite API: Register Remote Signing + Send Confirmation Document
+     * Align với SdkeSignImpl.registerAndConfirm: gọi registerRemoteSigning -> parse sessionId -> sendConfirmationDocument
+     */
+    @ReactMethod
+    fun registerAndConfirm(
+        requestJson: String,
+        confirmationDocBase64: String,
+        promise: Promise
+    ) {
+        Log.d(TAG, "▶️ registerAndConfirm() called")
+        try {
+            SdkeSign.registerAndConfirm(
+                requestJson = requestJson,
+                confirmationDocBase64 = confirmationDocBase64,
+                callbackSuccess = { rawResponse ->
+                    Log.d(TAG, "✅ registerAndConfirm() success")
+                    val (eventMap, promiseMap) = createSeparateMaps { map ->
+                        map.putString("response", rawResponse)
+                    }
+                    sendEvent("onESignRegisterAndConfirmSuccess", eventMap)
+                    promise.resolve(promiseMap)
+                },
+                callbackError = { event, error ->
+                    val errorMessage = error.message ?: ""
+                    val errorCode = error.code.toString()
+                    Log.e(TAG, "❌ registerAndConfirm() 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)
+                }
+            )
+        } catch (e: Exception) {
+            Log.e(TAG, "❌ registerAndConfirm() exception: ${e.message}", e)
+            promise.reject("ESIGN_EXCEPTION", e.message, e)
+        }
+    }
+
     @ReactMethod
     fun signPdf(
         requestJson: String,
@@ -1514,25 +1711,13 @@ class EKYCModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMo
                 callbackError = { event, error ->
                     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)
+                    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)
                 }
             )
         } catch (e: Exception) {

package/dist/EKYCModule.d.ts

@@ -1,6 +1,6 @@
 import { EmitterSubscription } from 'react-native';
 import { NfcConfig, NfcError } from './src/types/ekycNFCType';
-import { SDKEkycResultWithEvent, SDKEkycResultStringWithEvent } from './src/types/ekycType';
+import { SDKEkycResultWithEvent, SDKEkycResultStringWithEvent, StartEkycUIResult } from './src/types/ekycType';
 import { C06Config } from './src/types/ekycC06Type';
 import { OcrConfig } from './src/types/ekycOCRType';
 import { LivenessConfig, SDKFaceDetectStatus } from './src/types/ekycLivenessType';
@@ -82,6 +82,13 @@ declare class SDKeKYC {
     sendConfirmationDocument(requestJson: string): Promise<{
         response: string;
     }>;
+    /**
+     * Composite API: Register Remote Signing + Send Confirmation Document
+     * Align với SdkeSignImpl.registerAndConfirm
+     */
+    registerAndConfirm(requestJson: string, confirmationDocBase64: string): Promise<{
+        response: string;
+    }>;
     onESignInitSuccess(callback: (data: ESignInitResult) => void): EmitterSubscription | null;
     onESignOpenSessionSuccess(callback: (data: ESignOpenSessionResult) => void): EmitterSubscription | null;
     onESignRegisterDeviceSuccess(callback: (data: {
@@ -111,7 +118,15 @@ declare class SDKeKYC {
     onESignSendConfirmationDocumentSuccess(callback: (data: {
         response: string;
     }) => void): EmitterSubscription | null;
+    onESignRegisterAndConfirmSuccess(callback: (data: {
+        response: string;
+    }) => void): EmitterSubscription | null;
     onESignError(callback: (error: ESignError) => void): EmitterSubscription | null;
+    /**
+     * Start eKYC UI flow. On success, result contains the same data as Android:
+     * data.ekycStateModel.eKYCFileModel.imageFace → result.imageFace (base64),
+     * result.imageFacePath (file path), result.imageOcrFront / imageOcrBack, result.transactionId.
+     */
     startEkycUI(appKey: string, flowSDK: string[], language: string, transactionId: string, appKeyConfig: {
         appKey: string;
         appKeyNfc: string;
@@ -159,7 +174,7 @@ declare class SDKeKYC {
             textFont?: string;
             textColor?: number;
         };
-    }): Promise<any>;
+    }): Promise<StartEkycUIResult>;
 }
 declare const sdkEKYC: SDKeKYC;
 export { SDKeKYC };

package/dist/EKYCModule.js

@@ -221,10 +221,12 @@ class SDKeKYC {
     }
     async startFaceCompare(config) {
         var _a;
-        this.validateConfig(config, ['appKey', 'selfieImage', 'idImage']);
+        // Support both `appKey` and docs' `appKeyFaceService`
+        const normalized = Object.assign(Object.assign({}, config), { appKey: (config.appKeyFaceService || config.appKey) });
+        this.validateConfig(normalized, ['appKey', 'selfieImage', 'idImage']);
         const nativeModule = this.ensureNativeModule();
         try {
-            return await nativeModule.startFaceCompare(config.appKey, (_a = config.transactionId) !== null && _a !== void 0 ? _a : '', config.selfieImage, config.idImage);
+            return await nativeModule.startFaceCompare(normalized.appKey, (_a = normalized.transactionId) !== null && _a !== void 0 ? _a : '', normalized.selfieImage, normalized.idImage);
         }
         catch (error) {
             console.error('Face Compare Error:', error);
@@ -700,6 +702,21 @@ class SDKeKYC {
             throw error;
         }
     }
+    /**
+     * Composite API: Register Remote Signing + Send Confirmation Document
+     * Align với SdkeSignImpl.registerAndConfirm
+     */
+    async registerAndConfirm(requestJson, confirmationDocBase64) {
+        const nativeModule = this.ensureNativeModule();
+        try {
+            const result = await nativeModule.registerAndConfirm(requestJson, confirmationDocBase64);
+            return result;
+        }
+        catch (error) {
+            console.error('eSign Register And Confirm Error:', error);
+            throw error;
+        }
+    }
     // eSign Event Listeners
     onESignInitSuccess(callback) {
         try {
@@ -861,6 +878,22 @@ class SDKeKYC {
             return null;
         }
     }
+    onESignRegisterAndConfirmSuccess(callback) {
+        try {
+            const emitter = this.ensureEventEmitter();
+            if (!emitter) {
+                console.error('❌ Event emitter not available for onESignRegisterAndConfirmSuccess');
+                return null;
+            }
+            const listener = emitter.addListener('onESignRegisterAndConfirmSuccess', callback);
+            this.listeners.push(listener);
+            return listener;
+        }
+        catch (error) {
+            console.error('Failed to add onESignRegisterAndConfirmSuccess listener:', error);
+            return null;
+        }
+    }
     onESignError(callback) {
         try {
             const emitter = this.ensureEventEmitter();
@@ -877,7 +910,11 @@ class SDKeKYC {
             return null;
         }
     }
-    // SdkEkycUI method
+    /**
+     * Start eKYC UI flow. On success, result contains the same data as Android:
+     * data.ekycStateModel.eKYCFileModel.imageFace → result.imageFace (base64),
+     * result.imageFacePath (file path), result.imageOcrFront / imageOcrBack, result.transactionId.
+     */
     async startEkycUI(appKey, flowSDK, language, transactionId, appKeyConfig, optionConfig, styleConfig) {
         if (!this.isInitialized) {
             throw new Error('SDK is not initialized. Please call initSdkEkyc() first.');
@@ -892,7 +929,7 @@ class SDKeKYC {
             const appKeyConfigJson = JSON.stringify(appKeyConfig);
             const styleConfigJson = styleConfig ? JSON.stringify(styleConfig) : '{}';
             const nativeModule = this.ensureNativeModule();
-            const result = await nativeModule.startEkycUI(appKey, flowSDKJson, language, transactionId, optionConfigJson, appKeyConfigJson, styleConfigJson);
+            const result = (await nativeModule.startEkycUI(appKey, flowSDKJson, language, transactionId, optionConfigJson, appKeyConfigJson, styleConfigJson));
             console.log('✅ SdkEkycUI started successfully');
             return result;
         }