@finos_sdk/sdk-ekyc 1.4.6 → 1.4.8

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

@@ -13,10 +13,14 @@ 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.ReadableMap
 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
+import com.facebook.react.ReactRootView
+import com.facebook.react.ReactApplication
+import com.facebook.react.bridge.ReactContext
 import finos.sdk.c06.eKYCFinOSC06
 import finos.sdk.core.define.EKYCErrorResult
 import finos.sdk.core.define.EKYCEvent
@@ -44,6 +48,15 @@ import finos.sdk.smsotp.OTPFinOS
 import finos.sdk.core.model.sdk.config.SmsOtpConfig
 import vn.softdreams.easyca.sdk.eSignFinOS
 import vn.softdreams.easyca.sdk.esign.ESignModels
+import com.google.android.material.bottomsheet.BottomSheetDialog
+import android.view.LayoutInflater
+import android.view.View
+import android.widget.Button
+import android.widget.TextView
+import android.widget.LinearLayout
+import android.view.Gravity
+import android.graphics.Color
+import android.util.TypedValue
 
 import org.json.JSONArray
 import org.json.JSONObject
@@ -52,6 +65,8 @@ import java.io.FileOutputStream
 import java.io.FileInputStream
 import java.io.InputStream
 import java.util.Date
+import android.app.Activity
+import android.view.ViewGroup
 
 @ReactModule(name = EKYCModule.NAME)
 class EKYCModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaModule(reactContext) {
@@ -63,6 +78,362 @@ class EKYCModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMo
 
     override fun getName(): String = NAME
 
+    /**
+     * Reference tới BottomSheetDialog hiện đang hiển thị.
+     * @Volatile: resolveExit() chạy trên JS bridge thread, đọc field này được viết bởi UI thread.
+     * Không có @Volatile → JVM cache → bridge thread thấy stale null → dismiss bị bỏ qua.
+     */
+    @Volatile
+    private var currentExitSheet: BottomSheetDialog? = null
+
+    // Đánh dấu khi dismiss được trigger bởi resolveExit (button), không phải backdrop tap.
+    // @Volatile vì được set từ bridge thread, đọc từ UI thread trong setOnDismissListener.
+    @Volatile
+    private var exitSheetResolvedViaButton = false
+
+    private fun getTrueCurrentActivity(): Activity? {
+        // Try React Native's currentActivity first
+        val rnActivity = currentActivity
+        if (rnActivity != null && rnActivity.javaClass.simpleName != "MainActivity") {
+            return rnActivity
+        }
+
+        // If RN gives us MainActivity or null, but we know an SDK is showing, 
+        // we must find the actual top activity via reflection or ActivityThread
+        try {
+            val activityThreadClass = Class.forName("android.app.ActivityThread")
+            val activityThread = activityThreadClass.getMethod("currentActivityThread").invoke(null)
+            val activitiesField = activityThreadClass.getDeclaredField("mActivities")
+            activitiesField.isAccessible = true
+            
+            val activities = activitiesField.get(activityThread) as Map<Any, Any>
+            Log.d(TAG, "🔍 Scanning ${activities.size} activities...")
+            
+            var topActivity: Activity? = null
+            
+            for (activityRecord in activities.values) {
+                val activityRecordClass = activityRecord.javaClass
+                
+                val activityField = activityRecordClass.getDeclaredField("activity")
+                activityField.isAccessible = true
+                val activity = activityField.get(activityRecord) as Activity
+                
+                val pausedField = activityRecordClass.getDeclaredField("paused")
+                pausedField.isAccessible = true
+                val isPaused = pausedField.get(activityRecord) as Boolean
+                
+                val stoppedField = activityRecordClass.getDeclaredField("stopped")
+                stoppedField.isAccessible = true
+                val isStopped = stoppedField.get(activityRecord) as Boolean
+                
+                Log.d(TAG, "   - Found: ${activity.javaClass.simpleName} (Paused: $isPaused, Stopped: $isStopped, Finishing: ${activity.isFinishing})")
+                
+                if (!activity.isFinishing && !isStopped) {
+                    topActivity = activity
+                    if (!isPaused) break // Found the resumed one
+                }
+            }
+            return topActivity ?: rnActivity
+        } catch (e: Exception) {
+            Log.e(TAG, "Error finding true current activity", e)
+        }
+        
+        return rnActivity
+    }
+
+    @ReactMethod
+    fun showRNExitSheet(bundleName: String, initialProps: ReadableMap, promise: Promise) {
+        val activity = getTrueCurrentActivity() ?: run {
+            Log.e(TAG, "❌ showRNExitSheet failed: No visible activity found")
+            promise.reject("NO_ACTIVITY", "No visible activity found")
+            return
+        }
+
+        if (activity.isFinishing || activity.isDestroyed) {
+            Log.e(TAG, "❌ showRNExitSheet failed: Activity is finishing/destroyed")
+            promise.reject("ACTIVITY_INVALID", "Activity is finishing or destroyed")
+            return
+        }
+
+        // Guard chống double-resolve/reject promise (vì có nhiều entry point: sync error, async listener, exception)
+        val promiseSettled = java.util.concurrent.atomic.AtomicBoolean(false)
+        fun safeResolve(value: Any?) {
+            if (promiseSettled.compareAndSet(false, true)) promise.resolve(value)
+        }
+        fun safeReject(code: String, msg: String, e: Throwable? = null) {
+            if (promiseSettled.compareAndSet(false, true)) {
+                if (e != null) promise.reject(code, msg, e) else promise.reject(code, msg)
+            }
+        }
+
+        activity.runOnUiThread {
+            try {
+                val activityName = activity.javaClass.simpleName
+                Log.d(TAG, "▶️ showRNExitSheet: Top Activity=$activityName, bundle=$bundleName")
+
+                val reactApplication = activity.application as? ReactApplication
+                if (reactApplication == null) {
+                    Log.e(TAG, "❌ Application does not implement ReactApplication")
+                    safeReject("NO_REACT_APP", "Application does not implement ReactApplication")
+                    return@runOnUiThread
+                }
+                val reactInstanceManager = reactApplication.reactNativeHost.reactInstanceManager
+
+                if (reactInstanceManager.currentReactContext != null) {
+                    presentRNBottomSheet(activity, reactInstanceManager, bundleName, initialProps,
+                        ::safeResolve, ::safeReject)
+                    return@runOnUiThread
+                }
+
+                // Context chưa sẵn sàng: chờ listener
+                Log.w(TAG, "⚠️ ReactContext chưa ready, chờ init…")
+                val listener = object : com.facebook.react.ReactInstanceEventListener {
+                    override fun onReactContextInitialized(context: ReactContext) {
+                        reactInstanceManager.removeReactInstanceEventListener(this)
+                        activity.runOnUiThread {
+                            // Re-validate activity vì có thể đã destroy trong lúc chờ
+                            if (activity.isFinishing || activity.isDestroyed) {
+                                Log.w(TAG, "⚠️ Activity đã destroy trong lúc chờ ReactContext")
+                                safeReject("ACTIVITY_INVALID", "Activity destroyed while waiting for RN context")
+                                return@runOnUiThread
+                            }
+                            presentRNBottomSheet(activity, reactInstanceManager, bundleName, initialProps,
+                                ::safeResolve, ::safeReject)
+                        }
+                    }
+                }
+                reactInstanceManager.addReactInstanceEventListener(listener)
+
+                // FIX RACE: re-check sau khi add listener vì context có thể đã init
+                // giữa null-check ở trên và lúc add listener (listener không fire cho event đã xảy ra)
+                val ctxAfterAdd = reactInstanceManager.currentReactContext
+                if (ctxAfterAdd != null) {
+                    reactInstanceManager.removeReactInstanceEventListener(listener)
+                    Log.d(TAG, "✅ ReactContext init xong giữa lúc add listener — present luôn")
+                    presentRNBottomSheet(activity, reactInstanceManager, bundleName, initialProps,
+                        ::safeResolve, ::safeReject)
+                    return@runOnUiThread
+                }
+
+                // Chỉ trigger background create nếu chưa start (tránh IllegalStateException)
+                if (!reactInstanceManager.hasStartedCreatingInitialContext()) {
+                    try {
+                        reactInstanceManager.createReactContextInBackground()
+                    } catch (e: Exception) {
+                        reactInstanceManager.removeReactInstanceEventListener(listener)
+                        Log.e(TAG, "❌ Failed createReactContextInBackground", e)
+                        safeReject("RN_CONTEXT_INIT_FAILED", e.message ?: "createReactContextInBackground failed", e)
+                    }
+                }
+            } catch (e: Exception) {
+                Log.e(TAG, "❌ Exception in showRNExitSheet", e)
+                safeReject("RN_SHEET_ERROR", e.message ?: "unknown", e)
+            }
+        }
+    }
+
+    /**
+     * Hiển thị BottomSheetDialog chứa ReactRootView. Phải gọi trên UI thread.
+     *
+     * Quan trọng:
+     *  - Set BottomSheetBehavior.peekHeight = sheetHeight và state = STATE_EXPANDED
+     *    để sheet xuất hiện đầy đủ (mặc định peek nhỏ → sheet "không hiển thị" cảm giác).
+     *  - Auto-dismiss khi activity host bị detach (memory leak guard).
+     *  - safeResolve/safeReject để tránh promise resolve/reject 2 lần.
+     */
+    private fun presentRNBottomSheet(
+        activity: Activity,
+        reactInstanceManager: com.facebook.react.ReactInstanceManager,
+        bundleName: String,
+        initialProps: ReadableMap,
+        safeResolve: (Any?) -> Unit,
+        safeReject: (String, String, Throwable?) -> Unit
+    ) {
+        try {
+            val container = LinearLayout(activity).apply {
+                orientation = LinearLayout.VERTICAL
+                setBackgroundColor(Color.TRANSPARENT)
+            }
+
+            val rootView = ReactRootView(activity)
+            rootView.layoutParams = LinearLayout.LayoutParams(
+                LinearLayout.LayoutParams.MATCH_PARENT,
+                LinearLayout.LayoutParams.WRAP_CONTENT
+            )
+            container.addView(rootView)
+
+            // Bug 3 guard: nếu có sheet cũ chưa dismiss, dismiss nó trước để tránh leak
+            currentExitSheet?.let { old ->
+                if (old.isShowing) {
+                    try { old.dismiss() } catch (e: Exception) {
+                        Log.w(TAG, "presentRNBottomSheet: error dismissing old sheet: ${e.message}")
+                    }
+                }
+            }
+
+            val bottomSheetDialog = BottomSheetDialog(activity)
+            currentExitSheet = bottomSheetDialog
+            bottomSheetDialog.setContentView(container)
+            bottomSheetDialog.setCancelable(true)
+            bottomSheetDialog.setCanceledOnTouchOutside(true)
+
+            // isFitToContents=true → sheet height = wrap_content của ReactRootView,
+            // không expand fullscreen. setExitSheetHeight() từ JS sẽ fine-tune nếu cần.
+            bottomSheetDialog.setOnShowListener { dlg ->
+                val d = dlg as BottomSheetDialog
+                val bs = d.findViewById<View>(com.google.android.material.R.id.design_bottom_sheet)
+                    ?: return@setOnShowListener
+                val behavior = com.google.android.material.bottomsheet.BottomSheetBehavior.from(bs)
+                behavior.isFitToContents = true
+                behavior.skipCollapsed = true
+                behavior.state = com.google.android.material.bottomsheet.BottomSheetBehavior.STATE_EXPANDED
+            }
+
+            // Auto-dismiss & unmount khi activity decor view bị detach (activity destroy)
+            val decorView = activity.window.decorView
+            val attachListener = object : View.OnAttachStateChangeListener {
+                override fun onViewAttachedToWindow(v: View) {}
+                override fun onViewDetachedFromWindow(v: View) {
+                    decorView.removeOnAttachStateChangeListener(this)
+                    if (bottomSheetDialog.isShowing) {
+                        try { bottomSheetDialog.dismiss() } catch (_: Exception) {}
+                    }
+                }
+            }
+            decorView.addOnAttachStateChangeListener(attachListener)
+
+            bottomSheetDialog.setOnDismissListener {
+                currentExitSheet = null
+                decorView.removeOnAttachStateChangeListener(attachListener)
+                // Nếu dismiss KHÔNG phải từ button (backdrop tap / activity destroy),
+                // tự resolve CANCEL để SDK không bị kẹt và lần sau back vẫn trigger sheet lại.
+                if (!exitSheetResolvedViaButton && SDKeKYCExitHandlerManager.pendingCancel != null) {
+                    SDKeKYCExitHandlerManager.resolve("CANCEL")
+                    Log.d(TAG, "🔙 Sheet dismissed by backdrop — auto resolved CANCEL")
+                }
+                try {
+                    rootView.unmountReactApplication()
+                    Log.d(TAG, "🧹 RN sheet dismissed, root unmounted")
+                } catch (e: Exception) {
+                    Log.w(TAG, "Error unmounting ReactRootView: ${e.message}")
+                }
+            }
+
+            // Start RN trước show — view sẽ measure khi attached vào dialog window
+            rootView.startReactApplication(
+                reactInstanceManager,
+                bundleName,
+                Arguments.toBundle(initialProps)
+            )
+
+            bottomSheetDialog.show()
+
+            Log.d(TAG, "✅ showRNExitSheet: BottomSheetDialog shown (wrap content), bundle=$bundleName")
+            safeResolve(true)
+        } catch (e: Exception) {
+            Log.e(TAG, "❌ Exception in presentRNBottomSheet", e)
+            safeReject("RN_SHEET_ERROR", e.message ?: "unknown", e)
+        }
+    }
+
+    @ReactMethod
+    fun showNativeExitDialog(config: ReadableMap, promise: Promise) {
+        val activity = currentActivity ?: run {
+            promise.reject("NO_ACTIVITY", "Current activity is null")
+            return
+        }
+
+        val title = if (config.hasKey("title")) config.getString("title") else "Xác nhận thoát"
+        val message = if (config.hasKey("message")) config.getString("message") else "Bạn có chắc chắn muốn thoát khỏi quá trình eKYC?"
+        val confirmText = if (config.hasKey("confirmText")) config.getString("confirmText") else "Thoát ra"
+        val cancelText = if (config.hasKey("cancelText")) config.getString("cancelText") else "Hủy bỏ"
+
+        activity.runOnUiThread {
+            try {
+                val bottomSheetDialog = BottomSheetDialog(activity)
+                
+                // Create a simple programmatic layout for the Bottom Sheet
+                val context = activity
+                val root = LinearLayout(context).apply {
+                    orientation = LinearLayout.VERTICAL
+                    setPadding(60, 40, 60, 80)
+                    setBackgroundColor(Color.WHITE)
+                }
+
+                // Title
+                val titleView = TextView(context).apply {
+                    text = title
+                    textSize = 20f
+                    setTextColor(Color.BLACK)
+                    setTypeface(null, android.graphics.Typeface.BOLD)
+                    gravity = Gravity.CENTER
+                    setPadding(0, 0, 0, 20)
+                }
+                root.addView(titleView)
+
+                // Message
+                val messageView = TextView(context).apply {
+                    text = message
+                    textSize = 16f
+                    setTextColor(Color.DKGRAY)
+                    gravity = Gravity.CENTER
+                    setPadding(0, 0, 0, 60)
+                }
+                root.addView(messageView)
+
+                // Buttons Container
+                val buttonsContainer = LinearLayout(context).apply {
+                    orientation = LinearLayout.HORIZONTAL
+                    layoutParams = LinearLayout.LayoutParams(
+                        LinearLayout.LayoutParams.MATCH_PARENT,
+                        LinearLayout.LayoutParams.WRAP_CONTENT
+                    )
+                }
+
+                // Cancel Button
+                val btnCancel = Button(context).apply {
+                    text = cancelText
+                    layoutParams = LinearLayout.LayoutParams(0, 140, 1f).apply {
+                        setMargins(0, 0, 10, 0)
+                    }
+                    setBackgroundColor(Color.parseColor("#F2F2F7"))
+                    setTextColor(Color.BLACK)
+                    setOnClickListener {
+                        SDKeKYCExitHandlerManager.resolve("CANCEL")
+                        bottomSheetDialog.dismiss()
+                        promise.resolve("CANCEL")
+                    }
+                }
+                buttonsContainer.addView(btnCancel)
+
+                // Confirm Button
+                val btnConfirm = Button(context).apply {
+                    text = confirmText
+                    layoutParams = LinearLayout.LayoutParams(0, 140, 1f).apply {
+                        setMargins(10, 0, 0, 0)
+                    }
+                    setBackgroundColor(Color.parseColor("#FF3B30"))
+                    setTextColor(Color.WHITE)
+                    setOnClickListener {
+                        SDKeKYCExitHandlerManager.resolve("CONFIRM")
+                        bottomSheetDialog.dismiss()
+                        promise.resolve("CONFIRM")
+                    }
+                }
+                buttonsContainer.addView(btnConfirm)
+
+                root.addView(buttonsContainer)
+                bottomSheetDialog.setContentView(root)
+                bottomSheetDialog.setCancelable(false)
+                bottomSheetDialog.show()
+                
+            } catch (e: Exception) {
+                Log.e(TAG, "❌ showNativeExitDialog error: ${e.message}")
+                promise.reject("DIALOG_ERROR", e.message)
+            }
+        }
+    }
+
     private fun sendEvent(eventName: String, params: WritableMap?) {
         reactApplicationContext
             .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
@@ -97,6 +468,69 @@ class EKYCModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMo
         return Pair(eventMap, promiseMap)
     }
 
+    /**
+     * Convert snake_case (match_score) and kebab-case (to-be-reviewed) keys to camelCase.
+     * Native SDK responses use these formats via Gson @SerializedName, but TS API expects camelCase.
+     * Examples:
+     *   - "match_score"   → "matchScore"
+     *   - "to-be-reviewed" → "toBeReviewed"
+     *   - "ageRange"      → "ageRange" (already camelCase, unchanged)
+     */
+    private fun normalizeKeyToCamelCase(key: String): String {
+        if (!key.contains('_') && !key.contains('-')) return key
+        val parts = key.split('_', '-')
+        if (parts.isEmpty()) return key
+        val sb = StringBuilder(parts[0])
+        for (i in 1 until parts.size) {
+            val p = parts[i]
+            if (p.isEmpty()) continue
+            sb.append(p[0].uppercaseChar())
+            if (p.length > 1) sb.append(p.substring(1))
+        }
+        return sb.toString()
+    }
+
+    /** Recursively convert org.json.JSONObject → WritableMap (normalizes keys to camelCase). */
+    private fun jsonObjectToWritableMap(jsonObject: JSONObject): WritableMap {
+        val map = Arguments.createMap()
+        val keys = jsonObject.keys()
+        while (keys.hasNext()) {
+            val rawKey = keys.next()
+            val key = normalizeKeyToCamelCase(rawKey)
+            when (val value = jsonObject.get(rawKey)) {
+                is JSONObject -> map.putMap(key, jsonObjectToWritableMap(value))
+                is JSONArray  -> map.putArray(key, jsonArrayToWritableArray(value))
+                is Boolean    -> map.putBoolean(key, value)
+                is Int        -> map.putInt(key, value)
+                is Long       -> map.putDouble(key, value.toDouble())
+                is Double     -> map.putDouble(key, value)
+                is String     -> map.putString(key, value)
+                JSONObject.NULL -> map.putNull(key)
+                else          -> map.putString(key, value.toString())
+            }
+        }
+        return map
+    }
+
+    /** Recursively convert org.json.JSONArray → WritableArray. */
+    private fun jsonArrayToWritableArray(jsonArray: JSONArray): WritableArray {
+        val array = Arguments.createArray()
+        for (i in 0 until jsonArray.length()) {
+            when (val value = jsonArray.get(i)) {
+                is JSONObject -> array.pushMap(jsonObjectToWritableMap(value))
+                is JSONArray  -> array.pushArray(jsonArrayToWritableArray(value))
+                is Boolean    -> array.pushBoolean(value)
+                is Int        -> array.pushInt(value)
+                is Long       -> array.pushDouble(value.toDouble())
+                is Double     -> array.pushDouble(value)
+                is String     -> array.pushString(value)
+                JSONObject.NULL -> array.pushNull()
+                else          -> array.pushString(value.toString())
+            }
+        }
+        return array
+    }
+
     /** Convert ESignOpenSessionResult to WritableMap for RN. */
     private fun eSignOpenSessionResultToWritableMap(result: ESignModels.ESignOpenSessionResult): WritableMap =
         Arguments.createMap().apply {
@@ -430,8 +864,6 @@ class EKYCModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMo
         activeActionCount: Int?,
         forceCaptureTimeout: Double?,
         isActiveLivenessColor: Boolean?,
-        isShowBackConfirmation: Boolean?,
-        backConfirmConfigJson: String?,
         promise: Promise
     ) {
         Log.d(TAG, "▶️ startLiveness() called")
@@ -465,7 +897,7 @@ class EKYCModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMo
                 null
             }
 
-            val backConfirmConfig = parseBackConfirmConfig(backConfirmConfigJson)
+
             val livenessConfig =
                 LivenessConfig(
                     isActiveLiveness = isActiveLiveness ?: false,
@@ -480,9 +912,7 @@ class EKYCModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMo
                     activeActionCount = activeActionCount ?: 2,
                     forceCaptureTimeout = (forceCaptureTimeout ?: 0.0).toLong(),
                     selfieImage = imageFile,
-                    transactionId = transactionId,
-                    isShowBackConfirmation = isShowBackConfirmation ?: false,
-                    backConfirmConfig = backConfirmConfig,
+                    transactionId = transactionId
                 )
             val ekycConfig =
                 EKYCConfigSDK(
@@ -493,24 +923,25 @@ class EKYCModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMo
             eKYCFinOSLiveness.startEkyc(
                 ekycConfigSDK = ekycConfig,
                 callbackSuccess = { event, data ->
-                    // LOG_SUCCESS = internal submit result event (v1.4.6.1), don't resolve promise
-                    if (event == EKYCEvent.LOG_SUCCESS) {
-                        val logDataStr = data?.customData?.let { Gson().toJson(it) } ?: (data as? SDKEkycResult)?.checkLivenessResponse?.let { Gson().toJson(it) } ?: Gson().toJson(data)
-                        Log.d(TAG, "LOG_SUCCESS [Liveness]: $logDataStr")
-                        val logMap = Arguments.createMap().apply {
-                            putString("event", event.name.toString())
-                            putString("data", logDataStr)
-                        }
-                        sendEvent("onLivenessSuccess", logMap)
-                        return@startEkyc
-                    }
-                    Log.d(TAG, "✅ startLiveness() success")
-                    val (eventMap, promiseMap) = createSeparateMaps { map ->
-                        map.putString("event", event.name.toString())
-                        map.putString("data", Gson().toJson((data as SDKEkycResult).checkLivenessResponse))
-                    }
-                    sendEvent("onLivenessSuccess", eventMap)
-                    promise.resolve(promiseMap)
+                    Log.d(TAG, "🔥 NATIVE CALLBACK (Liveness): event=${event.name}")
+                    val response = (data as? SDKEkycResult)?.checkLivenessResponse
+                    val jsonStr = data?.customData?.let { Gson().toJson(it) } ?: Gson().toJson(response ?: data)
+
+                    // Helper to create fresh data map to avoid 'Map already consumed' error
+                    fun createWritableData() = try { jsonObjectToWritableMap(JSONObject(jsonStr)) } catch (e: Exception) { Arguments.createMap() }
+
+                    // Send the event directly to React Native
+                    sendEvent("onLivenessSuccess", Arguments.createMap().apply {
+                        putString("event", event.name)
+                        putMap("data", createWritableData())
+                    })
+
+                    // Always attempt to resolve the promise.
+                    // RN safely ignores subsequent resolves if the native SDK fires multiple events.
+                    promise.resolve(Arguments.createMap().apply { 
+                        putString("event", event.name)
+                        putMap("data", createWritableData()) 
+                    })
                 },
                 callbackError = { event, errorResult ->
                     Log.e(TAG, "❌ startLiveness() failed - Event: $event, Code: ${errorResult.code}, Message: ${errorResult.message}")
@@ -577,40 +1008,21 @@ class EKYCModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMo
                 eKYCFinOSFaceService.startEkyc(
                     ekycConfigSDK = ekycConfig,
                     callbackSuccess = { event, data ->
-                        // LOG_SUCCESS = internal submit result event (v1.4.6.1), don't resolve promise
-                        if (event == EKYCEvent.LOG_SUCCESS) {
-                            val faceResponse = (data as? SDKEkycResult)?.checkFaceResponse
-                            val logDataStr = data?.customData?.let { Gson().toJson(it) } ?: faceResponse?.let { Gson().toJson(it) } ?: "null"
-                            Log.d(TAG, "LOG_SUCCESS [FaceCompare]: $logDataStr")
-                            val logMap = Arguments.createMap().apply {
-                                putString("event", event.name.toString())
-                                putString("data", logDataStr)
-                            }
-                            sendEvent("onFaceCompareSuccess", logMap)
-                            return@startEkyc
-                        }
-                        Log.d(TAG, "✅ startFaceCompare() success")
-                        val faceResponse = (data as? SDKEkycResult)?.checkFaceResponse
-                        val (eventMap, promiseMap) = createSeparateMaps { map ->
-                            map.putString("event", event.name.toString())
-                            val resultMap = Arguments.createMap().apply {
-                                putDouble("conf", faceResponse?.result?.conf?.toString()?.toDoubleOrNull() ?: 0.0)
-                                putString("match", faceResponse?.result?.match?.toString())
-                                putInt("matchScore", faceResponse?.result?.matchScore?.toString()?.toIntOrNull() ?: 0)
-                                putString("toBeReviewed", faceResponse?.result?.toBeReviewed?.toString())
-                            }
-                            val faceMap = Arguments.createMap().apply {
-                                putString("requestId", faceResponse?.requestId?.toString())
-                                putMap("result", resultMap)
-                                putString("status", faceResponse?.status?.toString())
-                                putInt("statusCode", faceResponse?.statusCode?.toString()?.toIntOrNull() ?: 0)
-                                putString("error", faceResponse?.error?.toString())
-                                putString("type", faceResponse?.type?.toString())
-                            }
-                            map.putMap("data", faceMap)
-                        }
-                        sendEvent("onFaceCompareSuccess", eventMap)
-                        promise.resolve(promiseMap)
+                        Log.d(TAG, "🔥 NATIVE CALLBACK (Face Compare): event=${event.name}")
+                        val response = (data as? SDKEkycResult)?.checkFaceResponse
+                        val jsonStr = data?.customData?.let { Gson().toJson(it) } ?: Gson().toJson(response ?: data)
+                        fun createWritableData() = try { jsonObjectToWritableMap(JSONObject(jsonStr)) } catch (e: Exception) { Arguments.createMap() }
+
+                        sendEvent("onFaceCompareSuccess", Arguments.createMap().apply {
+                            putString("event", event.name)
+                            putMap("data", createWritableData())
+                        })
+
+                        // Always attempt to resolve the promise.
+                        promise.resolve(Arguments.createMap().apply {
+                            putString("event", event.name)
+                            putMap("data", createWritableData())
+                        })
                     },
                     callbackError = { event, errorResult ->
                         Log.e(TAG, "❌ startFaceCompare() failed - Event: $event, Code: ${errorResult.code}, Message: ${errorResult.message}")
@@ -806,18 +1218,13 @@ class EKYCModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMo
                 else -> AppIDType.NONE
             }
 
-            val isShowBackConfirmation = extractBooleanValue(optionConfigJson, "isShowBackConfirmation") ?: false
-            val backConfirmConfig = parseBackConfirmConfig(extractObjectJson(optionConfigJson, "backConfirmConfig"))
-
             val livenessConfig = if (finalFlow.contains(SDKType.LIVENESS)) {
                 LivenessConfig(
                     isActiveLiveness = isActiveLiveness,
                     forceCaptureTimeout = (forceCaptureTimeoutSec * 1000L).coerceAtLeast(0),
                     isShowCameraFont = switchFrontCamera,
                     customActions = customActionsList?.takeIf { it.isNotEmpty() },
-                    activeActionCount = activeActionCount,
-                    isShowBackConfirmation = isShowBackConfirmation,
-                    backConfirmConfig = backConfirmConfig,
+                    activeActionCount = activeActionCount
                 )
             } else null
 
@@ -835,41 +1242,71 @@ class EKYCModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMo
                 activity = currentActivity,
                 ekycConfigSDK = ekycConfigSDK,
                 callbackSuccess = { event, data ->
-                    // LOG_SUCCESS = internal submit result event (v1.4.5), emit event only, don't resolve promise
-                    if (event == EKYCEvent.LOG_SUCCESS) {
-                        val logDataStr = data?.customData?.let { Gson().toJson(it) } ?: Gson().toJson(data)
-                        Log.d(TAG, "LOG_SUCCESS [EkycUI]: $logDataStr")
-                        sendEvent("onEkycUISuccess", Arguments.createMap().apply {
-                            putString("status", "log")
-                            putString("event", event.name.toString())
-                            putString("data", logDataStr)
-                        })
-                        return@startEkyc
-                    }
-                    Log.d(TAG, "✅ startEkycUI() callback - event=${event.name}")
+                    Log.d(TAG, "🔥 NATIVE CALLBACK (EkycUI): 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 response = result?.ekycStateModel
+                    val jsonStr = data?.customData?.let { Gson().toJson(it) } ?: Gson().toJson(response ?: data)
+
+                    // Helper to create fresh data map to avoid 'Map already consumed' error
+                    fun createWritableData() = try { jsonObjectToWritableMap(JSONObject(jsonStr)) } catch (e: Exception) { Arguments.createMap() }
+
+                    val statusStr = when (event) {
+                        EKYCEvent.LOG_SUCCESS -> "log"
+                        EKYCEvent.SDK_START_SUCCESS -> "started"
+                        else -> "success"
+                    }
+
+                    // Send EVERY event directly to React Native Event Listener (Pass-through)
+                    sendEvent("onEkycUISuccess", Arguments.createMap().apply {
+                        putString("status", statusStr)
+                        putString("event", event.name)
+
+                        if (event == EKYCEvent.SDK_START_SUCCESS && response == null) {
+                            // Bỏ qua data nếu là SDK_START_SUCCESS (chỉ có event/status) để giống code cũ
+                        } else {
+                            putMap("data", createWritableData())
+                        }
+
+                        // Retain the convenient root properties cho backward compatibility
                         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", Gson().toJson(data))
-                            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)
+                        if (ekycTransactionId.isNotEmpty()) putString("transactionId", ekycTransactionId)
+                        ekycFiles?.imageFace?.absolutePath?.let { putString("imageFacePath", it) }
+                        ekycFiles?.imageOcrFront?.absolutePath?.let { putString("imageOcrFrontPath", it) }
+                        ekycFiles?.imageOcrBack?.absolutePath?.let { putString("imageOcrBackPath", it) }
+                    })
+
+                    // Re-emit onLivenessSuccess: dùng checkLivenessResponse (đúng format
+                    // CheckLivenessResponse) thay vì ekycStateModel để JS nhận đủ fields.
+                    if (event == EKYCEvent.LIVENESS_SUCCESS || event == EKYCEvent.LOG_SUCCESS) {
+                        val lrJson = result?.checkLivenessResponse
+                            ?.let { Gson().toJson(it) }
+                            ?: data?.customData?.let { Gson().toJson(it) }
+                            ?: jsonStr
+                        fun createLivenessData() = try {
+                            jsonObjectToWritableMap(JSONObject(lrJson))
+                        } catch (e: Exception) { Arguments.createMap() }
+                        sendEvent("onLivenessSuccess", Arguments.createMap().apply {
+                            putString("event", event.name)
+                            putMap("data", createLivenessData())
+                        })
+                    }
+
+                    // IMPORTANT: Chỉ resolve promise ở SDK_END_SUCCESS để `await FinosEKYC.startEkycUI()` không bị kết thúc sớm
+                    if (event == EKYCEvent.SDK_END_SUCCESS) {
+                        promise.resolve(Arguments.createMap().apply { 
+                            putString("status", "success")
+                            putString("event", event.name)
+                            putMap("data", createWritableData()) 
+                            
+                            val ekycFiles = result?.ekycStateModel?.eKYCFileModel
+                            val ekycTransactionId = result?.ekycStateModel?.transactionId ?: ""
+                            if (ekycTransactionId.isNotEmpty()) putString("transactionId", ekycTransactionId)
+                            ekycFiles?.imageFace?.absolutePath?.let { putString("imageFacePath", it) }
+                            ekycFiles?.imageOcrFront?.absolutePath?.let { putString("imageOcrFrontPath", it) }
+                            ekycFiles?.imageOcrBack?.absolutePath?.let { putString("imageOcrBackPath", it) }
+                        })
                     }
                 },
                 callbackError = { event, errorResult ->
@@ -881,14 +1318,14 @@ class EKYCModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMo
                         putString("customMessage", errorResult.message)
                         putString("message", errorResult.message)
                     }
+                    sendEvent("onEkycUIError", errorMap)
+                    
                     val promiseErrorMap = Arguments.createMap().apply {
                         putString("status", "error")
                         putString("event", event.name.toString())
                         putString("customCode", errorResult.code)
                         putString("customMessage", errorResult.message)
-                        putString("message", errorResult.message)
                     }
-                    sendEvent("onEkycUIError", errorMap)
                     promise.reject(event.name.toString(), errorResult.message, null, promiseErrorMap)
                 }
             )
@@ -943,24 +1380,7 @@ class EKYCModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMo
         }
     }
 
-    private fun parseBackConfirmConfig(json: String?): LivenessBackConfirmConfig? {
-        if (json.isNullOrBlank() || json == "{}") return null
-        return try {
-            LivenessBackConfirmConfig(
-                titleVi = extractStringValue(json, "titleVi"),
-                titleEn = extractStringValue(json, "titleEn"),
-                bodyVi = extractStringValue(json, "bodyVi"),
-                bodyEn = extractStringValue(json, "bodyEn"),
-                confirmButtonVi = extractStringValue(json, "confirmButtonVi"),
-                confirmButtonEn = extractStringValue(json, "confirmButtonEn"),
-                cancelButtonVi = extractStringValue(json, "cancelButtonVi"),
-                cancelButtonEn = extractStringValue(json, "cancelButtonEn"),
-            )
-        } catch (e: Exception) {
-            Log.e(TAG, "Error parsing backConfirmConfig: ${e.message}", e)
-            null
-        }
-    }
+
 
     private fun extractIntValue(json: String, key: String): Int? {
         return try {
@@ -2174,4 +2594,95 @@ class EKYCModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMo
         }
     }
 
+    @ReactMethod
+    fun registerExitHandler(promise: Promise) {
+        Log.d(TAG, "▶️ registerExitHandler() called")
+        try {
+            SDKeKYCExitHandlerManager.uiListener = { fm ->
+                sendEvent("onShowExitConfirm", Arguments.createMap())
+            }
+            SDKeKYCExitHandlerManager.register()
+            promise.resolve(true)
+        } catch (e: Exception) {
+            Log.e(TAG, "❌ registerExitHandler() exception: ${e.message}", e)
+            promise.reject("REGISTER_EXIT_HANDLER_EXCEPTION", e.message, e)
+        }
+    }
+
+    @ReactMethod
+    fun resolveExit(action: String, promise: Promise) {
+        Log.d(TAG, "▶️ resolveExit() called with action: $action")
+        try {
+            val sheet = currentExitSheet
+            val activity = getTrueCurrentActivity()
+
+            if (sheet != null && sheet.isShowing && activity != null) {
+                // Đánh dấu trước khi dismiss để setOnDismissListener biết đây là button-triggered,
+                // không phải backdrop tap → tránh auto-resolve CANCEL sai.
+                exitSheetResolvedViaButton = true
+                val latch = java.util.concurrent.CountDownLatch(1)
+                activity.runOnUiThread {
+                    try {
+                        sheet.dismiss()
+                    } catch (e: Exception) {
+                        Log.w(TAG, "resolveExit: error dismissing sheet: ${e.message}")
+                    } finally {
+                        latch.countDown()
+                    }
+                }
+                latch.await(500, java.util.concurrent.TimeUnit.MILLISECONDS)
+                exitSheetResolvedViaButton = false
+            }
+
+            // Gọi SDK callback SAU KHI sheet đã dismiss
+            SDKeKYCExitHandlerManager.resolve(action)
+            promise.resolve(true)
+        } catch (e: Exception) {
+            Log.e(TAG, "❌ resolveExit() exception: ${e.message}", e)
+            promise.reject("RESOLVE_EXIT_EXCEPTION", e.message, e)
+        }
+    }
+
+    @ReactMethod
+    fun setExitSheetHeight(heightDp: Float) {
+        val activity = getTrueCurrentActivity() ?: return
+        val heightPx = (heightDp * activity.resources.displayMetrics.density).toInt()
+        Log.d(TAG, "▶️ setExitSheetHeight: ${heightDp}dp → ${heightPx}px")
+        activity.runOnUiThread {
+            val sheet = currentExitSheet ?: return@runOnUiThread
+            if (!sheet.isShowing) return@runOnUiThread
+            val bs = sheet.findViewById<View>(com.google.android.material.R.id.design_bottom_sheet)
+                ?: return@runOnUiThread
+            val lp = bs.layoutParams ?: return@runOnUiThread
+            lp.height = heightPx
+            bs.layoutParams = lp
+            val behavior = com.google.android.material.bottomsheet.BottomSheetBehavior.from(bs)
+            behavior.peekHeight = heightPx
+            behavior.state = com.google.android.material.bottomsheet.BottomSheetBehavior.STATE_EXPANDED
+        }
+    }
+
+    @ReactMethod
+    fun addListener(eventName: String) {
+        // Keep: Required for RN built-in Event Emitter Calls.
+    }
+
+    @ReactMethod
+    fun removeListeners(count: Int) {
+        // Keep: Required for RN built-in Event Emitter Calls.
+    }
+
+    override fun onCatalystInstanceDestroy() {
+        super.onCatalystInstanceDestroy()
+        SDKeKYCExitHandlerManager.uiListener = null
+        // Dismiss sheet nếu vẫn đang hiển thị khi RN catalyst instance destroy
+        val sheet = currentExitSheet
+        currentExitSheet = null
+        if (sheet != null && sheet.isShowing) {
+            val activity = currentActivity
+            activity?.runOnUiThread {
+                try { sheet.dismiss() } catch (_: Exception) {}
+            }
+        }
+    }
 }