@finos_sdk/sdk-ekyc 0.0.40 → 0.0.42

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

@@ -1,9 +1,5 @@
-// ... existing code ...
 package finos.sdk.ekyc
 
-// Reuse the same implementation as app module to expose RN bridge
-// If needed, consider refactoring common code to a shared sourceSet
-
 import android.R
 import android.util.Base64
 import android.util.Log
@@ -39,74 +35,6 @@ import java.io.File
 import java.io.FileOutputStream
 import java.util.Date
 
-@ReactModule(name = EKYCModule.NAME)
-class EKYCModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaModule(reactContext) {
-
-    companion object {
-        const val NAME = "EKYCModule"
-        private const val TAG = "EKYCModule"
-    }
-
-    override fun getName(): String = NAME
-
-    private fun sendEvent(eventName: String, params: WritableMap?) {
-        reactApplicationContext
-            .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
-            .emit(eventName, params)
-    }
-
-    @ReactMethod
-    fun initSdkEkyc(promise: Promise) {
-        try {
-            SdkEkyc.initSDKEkyc(reactApplicationContext) {
-                val params = Arguments.createMap().apply {
-                    putString("status", "success")
-                    putString("message", "SDK EKYC initialized successfully")
-                }
-                sendEvent("EKYCInitEvent", params)
-                promise.resolve(true)
-            }
-        } catch (e: Exception) {
-            promise.reject("INIT_ERROR", "Failed to initialize SDK EKYC: ${e.message}")
-        }
-    }
-
-    // The rest of methods mirror the app module implementation
-    // startNfcScan, checkC06, startOcr, startLiveness, startFaceCompare, onResume, onPause, handleNewIntent, startEkycUI
-    // For brevity in this edit, reuse the same content as in app module `EKYCModule.kt`.
-}
-
-package finos.sdk.ekyc
-
-import android.util.Base64
-import android.util.Log
-import com.facebook.react.bridge.Arguments
-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.WritableMap
-import com.facebook.react.module.annotations.ReactModule
-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.model.response.SDKEkycResult
-import finos.sdk.core.model.sdk.config.C06Config
-import finos.sdk.core.model.sdk.config.EKYCConfigSDK
-import finos.sdk.core.model.sdk.config.FaceServiceConfig
-import finos.sdk.core.model.sdk.config.LivenessConfig
-import finos.sdk.core.model.sdk.config.NfcConfig
-import finos.sdk.core.model.sdk.config.OcrConfig
-import finos.sdk.ekyc.SdkEkyc
-import finos.sdk.faceservice.SdkEkycFaceService
-import finos.sdk.liveness.SdkEkycLiveness
-import finos.sdk.nfc.SdkEkycNfc
-import finos.sdk.ocr.SdkEkycOcr
-import java.io.File
-import java.io.FileOutputStream
-import java.util.Date
-
 @ReactModule(name = EKYCModule.NAME)
 class EKYCModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaModule(reactContext) {
 
@@ -133,6 +61,7 @@ class EKYCModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMo
                         putString("message", "SDK EKYC initialized successfully")
                     }
                 sendEvent("EKYCInitEvent", params)
+                //promise.resolve("SDK EKYC initialized successfully")
                 promise.resolve(true)
             }
         } catch (e: Exception) {
@@ -167,7 +96,7 @@ class EKYCModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMo
             )
 
             val ekycConfig =
-                EKYCConfigSDK(appKey = appKey, sdkType = SDKType.NFC, nfcConfig = nfcConfig)
+                EKYCConfigSDK(appKey = AppKeyConfig(appKey), sdkType = SDKType.NFC, nfcConfig = nfcConfig)
 
             SdkEkycNfc.startEkyc(
                 activity = currentActivity,
@@ -179,7 +108,7 @@ class EKYCModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMo
                         EKYCEvent.SCAN_NFC_START -> {
                             val eventMap =
                                 Arguments.createMap().apply {
-                                    putString("event", event.name)
+                                    putString("event", event.name.toString())
                                     putString("data", data.toString())
                                 }
                             sendEvent("onNfcScanStart", eventMap)
@@ -188,13 +117,13 @@ class EKYCModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMo
                         EKYCEvent.SCAN_NFC_SUCCESS -> {
                             val eventMap =
                                 Arguments.createMap().apply {
-                                    putString("event", event.name)
+                                    putString("event", event.name.toString())
                                     putString("data", (data as SDKEkycResult).nfcResponse)
                                 }
                             sendEvent("onNfcScanSuccess", eventMap)
                             val promiseMap =
                                 Arguments.createMap().apply {
-                                    putString("event", event.name)
+                                    putString("event", event.name.toString())
                                     putString("data", (data as SDKEkycResult).nfcResponse)
                                 }
                             promise.resolve(promiseMap)
@@ -203,7 +132,7 @@ class EKYCModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMo
                         else -> {
                             val eventMap =
                                 Arguments.createMap().apply {
-                                    putString("event", event.name)
+                                    putString("event", event.name.toString())
                                     putString("data", data.toString())
                                 }
                             sendEvent("onNfcEvent", eventMap)
@@ -215,12 +144,12 @@ class EKYCModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMo
 
                     val errorMap =
                         Arguments.createMap().apply {
-                            putString("event", event.name)
-                            putString("message", message ?: "Unknown error")
+                            putString("event", event.name.toString())
+                            putString("message", message?.toString() ?: "Unknown error")
                         }
 
                     sendEvent("onNfcError", errorMap)
-                    promise.reject(event.name, message ?: "Unknown NFC error")
+                    promise.reject(event.name.toString(), message?.toString() ?: "Unknown NFC error")
                 }
             )
             Log.d(TAG, "startNfcScan:::222222")
@@ -248,22 +177,23 @@ class EKYCModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMo
                     recentLocation = recentLocation
                 )
 
-            val ekycConfig = EKYCConfigSDK(appKey = appKey, c06Config = c06Config)
+            val ekycConfig = EKYCConfigSDK(appKey = AppKeyConfig(appKey), c06Config = c06Config)
 
             SdkEkycC06.startEkyc(
                 ekycConfigSDK = ekycConfig,
                 callbackSuccess = { event, data ->
                     Log.d(TAG, "C06 Success - Event: $event, Data: $data")
 
+                    // Create separate maps for event and promise
                     val eventMap =
                         Arguments.createMap().apply {
-                            putString("event", event.name)
+                            putString("event", event.name.toString())
                             putString("data", data.toString())
                         }
 
                     val promiseMap =
                         Arguments.createMap().apply {
-                            putString("event", event.name)
+                            putString("event", event.name.toString())
                             putString("data", data.toString())
                         }
                     sendEvent("onC06Success", eventMap)
@@ -274,12 +204,12 @@ class EKYCModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMo
 
                     val errorMap =
                         Arguments.createMap().apply {
-                            putString("event", event.name)
-                            putString("message", message ?: "Unknown error")
+                            putString("event", event.name.toString())
+                            putString("message", message?.toString() ?: "Unknown error")
                         }
 
                     sendEvent("onC06Error", errorMap)
-                    promise.reject(event.name, message ?: "Unknown C06 error")
+                    promise.reject(event.name.toString(), message?.toString() ?: "Unknown C06 error")
                 }
             )
         } catch (e: Exception) {
@@ -315,14 +245,14 @@ class EKYCModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMo
                     transactionId = transactionId
                 )
             val ekycConfig =
-                EKYCConfigSDK(appKey = appKey, sdkType = SDKType.OCR, ocrConfig = ocrConfig)
+                EKYCConfigSDK(appKey = AppKeyConfig(appKey), sdkType = SDKType.OCR, ocrConfig = ocrConfig)
             SdkEkycOcr.startEkyc(
                 ekycConfigSDK = ekycConfig,
                 callbackSuccess = { event, data ->
                     Log.d(TAG, "OCR Success - Event: $event, Data: $data")
                     val resultMap =
                         Arguments.createMap().apply {
-                            putString("event", event.name)
+                            putString("event", event.name.toString())
                             putString(
                                 "data",
                                 (data as SDKEkycResult).ocrResponse.toString()
@@ -331,7 +261,7 @@ class EKYCModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMo
                     sendEvent("onOcrSuccess", resultMap)
                     val promiseMap =
                         Arguments.createMap().apply {
-                            putString("event", event.name)
+                            putString("event", event.name.toString())
                             putString(
                                 "data",
                                 (data as SDKEkycResult).ocrResponse.toString()
@@ -343,11 +273,11 @@ class EKYCModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMo
                     Log.e(TAG, "OCR Error - Event: $event, Message: $message")
                     val errorMap =
                         Arguments.createMap().apply {
-                            putString("event", event.name)
-                            putString("message", message ?: "Unknown error")
+                            putString("event", event.name.toString())
+                            putString("message", message?.toString() ?: "Unknown error")
                         }
                     sendEvent("onOcrError", errorMap)
-                    promise.reject(event.name, message ?: "Unknown OCR error")
+                    promise.reject(event.name.toString(), message?.toString() ?: "Unknown OCR error")
                 }
             )
         } catch (e: Exception) {
@@ -386,8 +316,8 @@ class EKYCModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMo
                 )
             val ekycConfig =
                 EKYCConfigSDK(
-                    appKey = appKey,
-                    sdkType = SDKType.LIVE_NESS,
+                    appKey = AppKeyConfig(appKey),
+                    sdkType = SDKType.LIVENESS,
                     livenessConfig = livenessConfig
                 )
             SdkEkycLiveness.startEkyc(
@@ -396,7 +326,7 @@ class EKYCModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMo
                     Log.d(TAG, "Liveness Success - Event: $event, Data: $data")
                     val resultMap =
                         Arguments.createMap().apply {
-                            putString("event", event.name)
+                            putString("event", event.name.toString())
                             putString(
                                 "data",
                                 (data as SDKEkycResult).checkLivenessResponse.toString()
@@ -405,7 +335,7 @@ class EKYCModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMo
                     sendEvent("onLivenessSuccess", resultMap)
                     val promiseMap =
                         Arguments.createMap().apply {
-                            putString("event", event.name)
+                            putString("event", event.name.toString())
                             putString(
                                 "data",
                                 (data as SDKEkycResult).checkLivenessResponse.toString()
@@ -417,11 +347,11 @@ class EKYCModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMo
                     Log.e(TAG, "Liveness Error - Event: $event, Message: $message")
                     val errorMap =
                         Arguments.createMap().apply {
-                            putString("event", event.name)
-                            putString("message", message ?: "Unknown error")
+                            putString("event", event.name.toString())
+                            putString("message", message?.toString() ?: "Unknown error")
                         }
                     sendEvent("onLivenessError", errorMap)
-                    promise.reject(event.name, message ?: "Unknown Liveness error")
+                    promise.reject(event.name.toString(), message?.toString() ?: "Unknown Liveness error")
                 }
             )
         } catch (e: Exception) {
@@ -453,7 +383,6 @@ class EKYCModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMo
 
             val faceServiceConfig =
                 FaceServiceConfig(
-                    appKey = appKey,
                     transactionId = transactionId,
                     selfieImage = imageFile,
                     idImage = idImageFile
@@ -465,13 +394,13 @@ class EKYCModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMo
                     Log.d(TAG, "Face Compare Success - Event: $event, Data: $data")
                     val resultMap =
                         Arguments.createMap().apply {
-                            putString("event", event.name)
+                            putString("event", event.name.toString())
                             putString("data", data.toString())
                         }
                     sendEvent("onFaceCompareSuccess", resultMap)
                     val promiseMap =
                         Arguments.createMap().apply {
-                            putString("event", event.name)
+                            putString("event", event.name.toString())
                             putString("data", data.toString())
                         }
                     promise.resolve(promiseMap)
@@ -480,11 +409,11 @@ class EKYCModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMo
                     Log.e(TAG, "FaceService Error - Event: $event, Message: $message")
                     val errorMap =
                         Arguments.createMap().apply {
-                            putString("event", event.name)
-                            putString("message", message ?: "Unknown error")
+                            putString("event", event.name.toString())
+                            putString("message", message?.toString() ?: "Unknown error")
                         }
                     sendEvent("onFaceCompareError", errorMap)
-                    promise.reject(event.name, message ?: "Unknown FaceService error")
+                    promise.reject(event.name.toString(), message?.toString() ?: "Unknown FaceService error")
                 }
             )
         } catch (e: Exception) {
@@ -516,26 +445,332 @@ class EKYCModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMo
 
     private fun base64ToImageFile(base64Image: String): File {
         try {
+            // Remove data URI prefix if present (like "data:image/png;base64,")
             var processedBase64 = base64Image
             if (base64Image.contains(",")) {
                 processedBase64 = base64Image.split(",")[1]
             }
 
+            // Decode base64 string to bytes
             val bytes = Base64.decode(processedBase64, Base64.DEFAULT)
+
+            // Create a unique filename with timestamp
             val timestamp = Date().time.toString()
             val fileName = "image_$timestamp.jpg"
+
+            // Get temporary directory and create file path
             val directory = reactApplicationContext.cacheDir
             val filePath = "${directory.path}/$fileName"
+
+            // Write bytes to file
             val imageFile = File(filePath)
             FileOutputStream(imageFile).use { it.write(bytes) }
+
             return imageFile
         } catch (e: Exception) {
             Log.e("LivenessFragment", "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")
             errorFile.createNewFile()
             return errorFile
         }
     }
-}
 
+    @ReactMethod
+    fun startEkycUI(
+        appKey: String,
+        flowSDK: String, // JSON string array like "[\"OCR\", \"NFC\", \"LIVENESS\"]"
+        language: String,
+        transactionId: String,
+        optionConfigJson: String, // JSON string for option config
+        appKeyConfigJson: String, // JSON string for app key config
+        styleConfigJson: String, // JSON string for style config
+        promise: Promise
+    ) {
+        try {
+            val currentActivity = currentActivity
+            if (currentActivity == null) {
+                promise.reject("NO_ACTIVITY", "Activity not available")
+                return
+            }
+
+            Log.d(TAG, "startEkycUI: appKey=$appKey, flowSDK=$flowSDK, language=$language, optionConfig=$optionConfigJson, appKeyConfig=$appKeyConfigJson, styleConfig=$styleConfigJson")
+
+            // Parse flowSDK JSON string to List<SDKType>
+            val flowList = parseFlowSDK(flowSDK)
+
+            // Use default flow if empty like MainActivity.kt startWithFlow
+            val finalFlow = if (flowList.isEmpty()) {
+                listOf(SDKType.OCR, SDKType.NFC, SDKType.LIVENESS)
+            } else {
+                flowList
+            }
+
+            // Parse OptionConfig JSON
+            val optionConfig = parseOptionConfig(optionConfigJson)
+
+            // Parse AppKeyConfig JSON from React Native
+            val appKeyConfig = parseAppKeyConfig(appKeyConfigJson)
+
+            // Parse StyleConfig JSON from React Native
+            val styleConfig = parseStyleConfig(styleConfigJson)
+
+            // Create EKYCConfigSDK like MainActivity.kt
+            val ekycConfigSDK = EKYCConfigSDK(
+                appKey = appKeyConfig,
+                optionConfig = optionConfig.copy(language = if (language == "en") "en" else "vi"),
+                styleConfig = styleConfig,
+                appIDType = AppIDType.VIKKI,
+                flowSDK = finalFlow
+            )
+
+            // Use actual SdkEkycUI.startEkyc like MainActivity.kt
+            Log.d(TAG, "Starting SdkEkycUI.startEkyc with config: $ekycConfigSDK")
+
+            SdkEkycUI.startEkyc(
+                activity = currentActivity,
+                ekycConfigSDK = ekycConfigSDK,
+                callbackSuccess = { event, data ->
+                    Log.d(TAG, "eKYC UI Success - Event: $event, Data: $data")
+                    val resultMap = Arguments.createMap().apply {
+                        putString("status", "success")
+                        putString("event", event.name.toString())
+                        putString("data", data.toString())
+                    }
+                    val eventMap = Arguments.createMap().apply {
+                        putString("status", "success")
+                        putString("event", event.name.toString())
+                        putString("data", data.toString())
+                    }
+                    sendEvent("onEkycUISuccess", eventMap)
+                    promise.resolve(resultMap)
+                },
+                callbackError = { event, errorResult ->
+                    Log.e(TAG, "eKYC UI Error - Event: $event, ErrorResult: $errorResult")
+                    val errorMap = Arguments.createMap().apply {
+                        putString("status", "error")
+                        putString("event", event.name.toString())
+                        putString("message", errorResult.message)
+                        putString("errorCode", errorResult.toString())
+                    }
+                    val promiseErrorMap = Arguments.createMap().apply {
+                        putString("status", "error")
+                        putString("event", event.name.toString())
+                        putString("message", errorResult.message)
+                        putString("errorCode", errorResult.toString())
+                    }
+                    sendEvent("onEkycUIError", errorMap)
+                    promise.reject(event.name.toString(), errorResult.message, Throwable(errorResult.message), promiseErrorMap)
+                }
+            )
+
+        } catch (e: Exception) {
+            Log.e(TAG, "Exception in startEkycUI: ${e.message}", e)
+            promise.reject("EKYC_UI_EXCEPTION", e.message, e)
+        }
+    }
+
+    private fun parseFlowSDK(flowSDKJson: String): List<SDKType> {
+        return try {
+            // Simple parsing for JSON array like ["OCR", "NFC", "LIVENESS"]
+            val cleanJson = flowSDKJson.replace("[", "").replace("]", "").replace("\"", "")
+            val flowArray = cleanJson.split(",").map { it.trim() }
+
+            flowArray.mapNotNull { sdkType ->
+                when (sdkType) {
+                    "OCR" -> SDKType.OCR
+                    "NFC" -> SDKType.NFC
+                    "LIVENESS" -> SDKType.LIVENESS
+                    else -> null
+                }
+            }
+        } catch (e: Exception) {
+            Log.e(TAG, "Error parsing flowSDK: ${e.message}", e)
+            // Default flow
+            listOf(SDKType.OCR, SDKType.NFC, SDKType.LIVENESS)
+        }
+    }
+
+    private fun parseOptionConfig(optionConfigJson: String): OptionConfig {
+        return try {
+            if (optionConfigJson.isBlank() || optionConfigJson == "{}") {
+                // Return default values based on demo OptionConfig.kt
+                OptionConfig(
+                    baseUrl = null,
+                    countMaxRetry = 3,
+                    language = null
+                )
+            } else {
+                // Simple JSON parsing (in real implementation, use proper JSON library)
+                val baseUrl = extractStringValue(optionConfigJson, "baseUrl")
+                val countMaxRetry = extractIntValue(optionConfigJson, "countMaxRetry") ?: 3
+                val language = extractStringValue(optionConfigJson, "language")
+
+                OptionConfig(
+                    baseUrl = baseUrl,
+                    countMaxRetry = countMaxRetry,
+                    language = language
+                )
+            }
+        } catch (e: Exception) {
+            Log.e(TAG, "Error parsing optionConfig: ${e.message}", e)
+            // Return default values
+            OptionConfig(
+                baseUrl = null,
+                countMaxRetry = 3,
+                language = null
+            )
+        }
+    }
+
+    private fun extractIntValue(json: String, key: String): Int? {
+        return try {
+            val pattern = "\"$key\"\\s*:\\s*(\\d+)".toRegex()
+            val match = pattern.find(json)
+            match?.groupValues?.get(1)?.toInt()
+        } catch (e: Exception) {
+            null
+        }
+    }
+
+    private fun extractBooleanValue(json: String, key: String): Boolean? {
+        return try {
+            val pattern = "\"$key\"\\s*:\\s*(true|false)".toRegex()
+            val match = pattern.find(json)
+            match?.groupValues?.get(1)?.toBoolean()
+        } catch (e: Exception) {
+            null
+        }
+    }
+
+    private fun parseAppKeyConfig(appKeyConfigJson: String): AppKeyConfig {
+        return try {
+            if (appKeyConfigJson.isBlank() || appKeyConfigJson == "{}") {
+                throw IllegalArgumentException("appKeyConfig is required and cannot be empty")
+            }
+
+            // Simple JSON parsing (in real implementation, use proper JSON library)
+            val appKey = extractStringValue(appKeyConfigJson, "appKey")
+                ?: throw IllegalArgumentException("appKey is required in appKeyConfig")
+            val appKeyNfc = extractStringValue(appKeyConfigJson, "appKeyNfc")
+                ?: throw IllegalArgumentException("appKeyNfc is required in appKeyConfig")
+            val appKeyOcr = extractStringValue(appKeyConfigJson, "appKeyOcr")
+                ?: throw IllegalArgumentException("appKeyOcr is required in appKeyConfig")
+            val appKeyLiveness = extractStringValue(appKeyConfigJson, "appKeyLiveness")
+                ?: throw IllegalArgumentException("appKeyLiveness is required in appKeyConfig")
+            val appKeyC06 = extractStringValue(appKeyConfigJson, "appKeyC06")
+                ?: throw IllegalArgumentException("appKeyC06 is required in appKeyConfig")
+            val appKeyFaceService = extractStringValue(appKeyConfigJson, "appKeyFaceService")
+                ?: throw IllegalArgumentException("appKeyFaceService is required in appKeyConfig")
+
+            AppKeyConfig(
+                appKey = appKey,
+                appKeyNfc = appKeyNfc,
+                appKeyOcr = appKeyOcr,
+                appKeyLiveness = appKeyLiveness,
+                appKeyC06 = appKeyC06,
+                appKeyFaceService = appKeyFaceService
+            )
+        } catch (e: Exception) {
+            Log.e(TAG, "Error parsing appKeyConfig: ${e.message}", e)
+            throw IllegalArgumentException("Invalid appKeyConfig: ${e.message}")
+        }
+    }
+
+    private fun parseStyleConfig(styleConfigJson: String): StyleConfig {
+        return try {
+            if (styleConfigJson.isBlank() || styleConfigJson == "{}") {
+                // Return default StyleConfig based on demo StyleConfig.kt
+                StyleConfig(
+                    textSize = 14,
+                    textFont = "",
+                    textColor = R.color.black,
+                    statusBarBackground = null,
+                    backIcon = null,
+                    titleStyle = null,
+                    toolbarStyle = null,
+                    instructionStyle = null,
+                    errorStyle = null,
+                    successStyle = null,
+                    warningStyle = null
+                )
+            } else {
+                // Parse StyleConfig JSON based on demo StyleConfig.kt structure
+                val textSize = extractIntValue(styleConfigJson, "textSize") ?: 14
+                val textFont = extractStringValue(styleConfigJson, "textFont") ?: ""
+                val textColor = extractIntValue(styleConfigJson, "textColor") ?: R.color.black
+
+                // Parse TextStyle objects
+                val titleStyle = parseTextStyle(styleConfigJson, "titleStyle")
+                val toolbarStyle = parseTextStyle(styleConfigJson, "toolbarStyle")
+                val instructionStyle = parseTextStyle(styleConfigJson, "instructionStyle")
+                val errorStyle = parseTextStyle(styleConfigJson, "errorStyle")
+                val successStyle = parseTextStyle(styleConfigJson, "successStyle")
+                val warningStyle = parseTextStyle(styleConfigJson, "warningStyle")
+
+                StyleConfig(
+                    textSize = textSize,
+                    textFont = textFont,
+                    textColor = textColor,
+                    statusBarBackground = null, // sdkui resources not available
+                    backIcon = null, // sdkui resources not available
+                    titleStyle = titleStyle,
+                    toolbarStyle = toolbarStyle,
+                    instructionStyle = instructionStyle,
+                    errorStyle = errorStyle,
+                    successStyle = successStyle,
+                    warningStyle = warningStyle
+                )
+            }
+        } catch (e: Exception) {
+            Log.e(TAG, "Error parsing styleConfig: ${e.message}", e)
+            // Return default values
+            StyleConfig(
+                textSize = 14,
+                textFont = "",
+                textColor = R.color.black,
+                statusBarBackground = null,
+                backIcon = null,
+                titleStyle = null,
+                toolbarStyle = null,
+                instructionStyle = null,
+                errorStyle = null,
+                successStyle = null,
+                warningStyle = null
+            )
+        }
+    }
 
+    private fun parseTextStyle(styleConfigJson: String, styleKey: String): StyleConfig.TextStyle? {
+        return try {
+            // Simple extraction for nested TextStyle objects
+            val textSize = extractIntValue(styleConfigJson, "${styleKey}.textSize")
+            val textFont = extractStringValue(styleConfigJson, "${styleKey}.textFont")
+            val textColor = extractIntValue(styleConfigJson, "${styleKey}.textColor")
+
+            if (textSize != null || textFont != null || textColor != null) {
+                StyleConfig.TextStyle(
+                    textSize = textSize,
+                    textFont = textFont,
+                    textColor = textColor
+                )
+            } else {
+                null
+            }
+        } catch (e: Exception) {
+            Log.e(TAG, "Error parsing TextStyle for $styleKey: ${e.message}", e)
+            null
+        }
+    }
+
+    private fun extractStringValue(json: String, key: String): String? {
+        return try {
+            val pattern = "\"$key\"\\s*:\\s*\"([^\"]+)\"".toRegex()
+            val match = pattern.find(json)
+            match?.groupValues?.get(1)
+        } catch (e: Exception) {
+            null
+        }
+    }
+
+}

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

@@ -15,24 +15,4 @@ class EKYCPackage : ReactPackage {
     }
 }
 
-package finos.sdk.ekyc
-
-import com.facebook.react.ReactPackage
-import com.facebook.react.bridge.NativeModule
-import com.facebook.react.bridge.ReactApplicationContext
-import com.facebook.react.uimanager.ViewManager
-
-class EKYCPackage : ReactPackage {
-
-    override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
-        return listOf(EKYCModule(reactContext))
-    }
-
-    override fun createViewManagers(
-        reactContext: ReactApplicationContext
-    ): List<ViewManager<*, *>> {
-        return emptyList()
-    }
-}
-
 

package/dist/EKYCModule.d.ts

@@ -5,7 +5,7 @@ import { C06Config } from './src/types/ekycC06Type';
 import { OcrConfig } from './src/types/ekycOCRType';
 import { LivenessConfig } from './src/types/ekycLivenessType';
 import { FaceServiceConfig } from './src/types/ekycFaceType';
-export declare const SDK_VERSION = "0.0.39";
+export declare const SDK_VERSION = "0.0.40";
 export declare const SDK_NAME = "@finos_sdk/sdk-ekyc";
 declare class SDKeKYC {
     private eventEmitter;

package/dist/EKYCModule.js

@@ -3,18 +3,19 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SDKeKYC = exports.SDK_NAME = exports.SDK_VERSION = void 0;
 const react_native_1 = require("react-native");
 // Version information
-exports.SDK_VERSION = '0.0.39';
+exports.SDK_VERSION = '0.0.40';
 exports.SDK_NAME = '@finos_sdk/sdk-ekyc';
 const EKYCNativeModule = react_native_1.NativeModules.EKYCModule;
 // Validate that the module is available
 if (!EKYCNativeModule) {
-    throw new Error('EKYCModule is not available. Make sure you have:\n' +
-        '1. Called SdkEkyc.initSDKEkyc() in native code\n' +
-        '2. Properly registered EKYCModule in MainApplication.kt\n' +
-        '3. Rebuilt your app completely\n' +
-        '4. If the error persists, try cleaning build folders:\n' +
-        '   - rm -rf android/app/build\n' +
-        '   - cd android && ./gradlew clean');
+    throw new Error('EKYCModule is not available. This is likely an autolinking issue.\n' +
+        'Please try:\n' +
+        '1. Clean and rebuild your app:\n' +
+        '   - rm -rf android/app/build android/build\n' +
+        '   - cd android && ./gradlew clean && cd ..\n' +
+        '   - npx react-native run-android\n' +
+        '2. If using manual linking, remove it and rely on autolinking\n' +
+        '3. Ensure you have the latest version: npm install @finos_sdk/sdk-ekyc@latest');
 }
 // Initialize the module with Koin error handling
 try {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@finos_sdk/sdk-ekyc",
-  "version": "0.0.40",
-  "description": "React Native SDK for eKYC (electronic Know Your Customer) - Vietnamese CCCD NFC reading, OCR, Liveness detection, Face matching, and C06 residence verification",
+  "version": "0.0.42",
+  "description": "React Native SDK for eKYC - Vietnamese CCCD NFC reading, OCR, Liveness detection, Face matching, and C06 residence verification",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "files": [