@finos_sdk/sdk-ekyc 0.0.22 → 0.0.23

package/android/src/main/java/com/sdkekycrn/EKYCModule.kt

@@ -1,3 +1,473 @@
-// ... existing code ...
+package com.sdkekycrn
 
+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) {
+
+    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("SDK EKYC initialized successfully")
+                promise.resolve(true)
+            }
+        } catch (e: Exception) {
+            promise.reject("INIT_ERROR", "Failed to initialize SDK EKYC: ${e.message}")
+        }
+    }
+
+    @ReactMethod
+    fun startNfcScan(
+        appKey: String,
+        documentNumber: String,
+        birthDate: String,
+        expireDate: String,
+        transactionId: String?,
+        facePathStorage: String?,
+        promise: Promise
+    ) {
+        try {
+            Log.d(TAG, "startNfcScan:::0000")
+            val currentActivity = reactApplicationContext.currentActivity
+            if (currentActivity == null) {
+                promise.reject("NO_ACTIVITY", "Activity not available")
+                return
+            }
+            Log.d(TAG, "startNfcScan:::1111")
+            val nfcConfig = NfcConfig(
+                documentNumber = documentNumber,
+                birthDate = birthDate,
+                expireDate = expireDate,
+                facePathStorage = facePathStorage ?: "",
+                transactionId = transactionId ?: ""
+            )
+
+            val ekycConfig =
+                EKYCConfigSDK(appKey = appKey, sdkType = SDKType.NFC, nfcConfig = nfcConfig)
+
+            SdkEkycNfc.startEkyc(
+                activity = currentActivity,
+                ekycConfigSDK = ekycConfig,
+                callbackSuccess = { event, data ->
+                    Log.d(TAG, "NFC Success - Event: $event, Data: $data")
+
+                    when (event) {
+                        EKYCEvent.SCAN_NFC_START -> {
+                            val eventMap =
+                                Arguments.createMap().apply {
+                                    putString("event", event.name)
+                                    putString("data", data.toString())
+                                }
+                            sendEvent("onNfcScanStart", eventMap)
+                        }
+
+                        EKYCEvent.SCAN_NFC_SUCCESS -> {
+                            val eventMap =
+                                Arguments.createMap().apply {
+                                    putString("event", event.name)
+                                    putString("data", (data as SDKEkycResult).nfcResponse)
+                                }
+                            sendEvent("onNfcScanSuccess", eventMap)
+                            val promiseMap =
+                                Arguments.createMap().apply {
+                                    putString("event", event.name)
+                                    putString("data", (data as SDKEkycResult).nfcResponse)
+                                }
+                            promise.resolve(promiseMap)
+                        }
+
+                        else -> {
+                            val eventMap =
+                                Arguments.createMap().apply {
+                                    putString("event", event.name)
+                                    putString("data", data.toString())
+                                }
+                            sendEvent("onNfcEvent", eventMap)
+                        }
+                    }
+                },
+                callbackError = { event, message ->
+                    Log.e(TAG, "NFC Error - Event: $event, Message: $message")
+
+                    val errorMap =
+                        Arguments.createMap().apply {
+                            putString("event", event.name)
+                            putString("message", message ?: "Unknown error")
+                        }
+
+                    sendEvent("onNfcError", errorMap)
+                    promise.reject(event.name, message ?: "Unknown NFC error")
+                }
+            )
+            Log.d(TAG, "startNfcScan:::222222")
+        } catch (e: Exception) {
+            Log.e(TAG, "Exception in startNfcScan: ${e.message}", e)
+            promise.reject("NFC_EXCEPTION", e.message, e)
+        }
+    }
+
+    @ReactMethod
+    fun checkC06(
+        appKey: String,
+        sod: String,
+        idCardNumber: String,
+        recentLocation: String,
+        transactionId: String?,
+        promise: Promise
+    ) {
+        try {
+            val c06Config =
+                C06Config(
+                    transactionId = transactionId ?: "",
+                    sod = sod,
+                    idCardNumber = idCardNumber,
+                    recentLocation = recentLocation
+                )
+
+            val ekycConfig = EKYCConfigSDK(appKey = 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("data", data.toString())
+                        }
+
+                    val promiseMap =
+                        Arguments.createMap().apply {
+                            putString("event", event.name)
+                            putString("data", data.toString())
+                        }
+                    sendEvent("onC06Success", eventMap)
+                    promise.resolve(promiseMap)
+                },
+                callbackError = { event, message ->
+                    Log.e(TAG, "C06 Error - Event: $event, Message: $message")
+
+                    val errorMap =
+                        Arguments.createMap().apply {
+                            putString("event", event.name)
+                            putString("message", message ?: "Unknown error")
+                        }
+
+                    sendEvent("onC06Error", errorMap)
+                    promise.reject(event.name, message ?: "Unknown C06 error")
+                }
+            )
+        } catch (e: Exception) {
+            Log.e(TAG, "Exception in checkC06: ${e.message}", e)
+            promise.reject("C06_EXCEPTION", e.message, e)
+        }
+    }
+
+    @ReactMethod
+    fun startOcr(
+        appKey: String,
+        idImage: String,
+        expectedDocumentSide: String,
+        transactionId: String,
+        promise: Promise
+    ) {
+        try {
+            val currentActivity = reactApplicationContext.currentActivity
+            if (currentActivity == null) {
+                promise.reject("NO_ACTIVITY", "Activity not available")
+                return
+            }
+            val imageFile = File(idImage.replace("file://", ""))
+            if (!imageFile.exists()) {
+                promise.reject("FILE_NOT_FOUND", "Image file does not exist")
+                return
+            }
+
+            val ocrConfig =
+                OcrConfig(
+                    idImage = imageFile,
+                    expectedDocumentSide = expectedDocumentSide,
+                    transactionId = transactionId
+                )
+            val ekycConfig =
+                EKYCConfigSDK(appKey = 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(
+                                "data",
+                                (data as SDKEkycResult).ocrResponse.toString()
+                            )
+                        }
+                    sendEvent("onOcrSuccess", resultMap)
+                    val promiseMap =
+                        Arguments.createMap().apply {
+                            putString("event", event.name)
+                            putString(
+                                "data",
+                                (data as SDKEkycResult).ocrResponse.toString()
+                            )
+                        }
+                    promise.resolve(promiseMap)
+                },
+                callbackError = { event, message ->
+                    Log.e(TAG, "OCR Error - Event: $event, Message: $message")
+                    val errorMap =
+                        Arguments.createMap().apply {
+                            putString("event", event.name)
+                            putString("message", message ?: "Unknown error")
+                        }
+                    sendEvent("onOcrError", errorMap)
+                    promise.reject(event.name, message ?: "Unknown OCR error")
+                }
+            )
+        } catch (e: Exception) {
+            Log.e(TAG, "Exception in startOcr: ${e.message}", e)
+            promise.reject("OCR_ERROR", e.message)
+        }
+    }
+
+    @ReactMethod
+    fun startLiveness(
+        appKey: String,
+        selfieImage: String,
+        usingRandomAction: Boolean,
+        transactionId: String,
+        isStraight: Boolean,
+        promise: Promise
+    ) {
+        try {
+            val currentActivity = reactApplicationContext.currentActivity
+            if (currentActivity == null) {
+                promise.reject("NO_ACTIVITY", "Activity not available")
+                return
+            }
+            val imageFile = File(selfieImage.replace("file://", ""))
+            if (!imageFile.exists()) {
+                promise.reject("FILE_NOT_FOUND", "Image file does not exist")
+                return
+            }
+
+            val livenessConfig =
+                LivenessConfig(
+                    selfieImage = imageFile,
+                    usingRandomAction = usingRandomAction,
+                    isStraight = isStraight,
+                    transactionId = transactionId
+                )
+            val ekycConfig =
+                EKYCConfigSDK(
+                    appKey = appKey,
+                    sdkType = SDKType.LIVE_NESS,
+                    livenessConfig = livenessConfig
+                )
+            SdkEkycLiveness.startEkyc(
+                ekycConfigSDK = ekycConfig,
+                callbackSuccess = { event, data ->
+                    Log.d(TAG, "Liveness Success - Event: $event, Data: $data")
+                    val resultMap =
+                        Arguments.createMap().apply {
+                            putString("event", event.name)
+                            putString(
+                                "data",
+                                (data as SDKEkycResult).checkLivenessResponse.toString()
+                            )
+                        }
+                    sendEvent("onLivenessSuccess", resultMap)
+                    val promiseMap =
+                        Arguments.createMap().apply {
+                            putString("event", event.name)
+                            putString(
+                                "data",
+                                (data as SDKEkycResult).checkLivenessResponse.toString()
+                            )
+                        }
+                    promise.resolve(promiseMap)
+                },
+                callbackError = { event, message ->
+                    Log.e(TAG, "Liveness Error - Event: $event, Message: $message")
+                    val errorMap =
+                        Arguments.createMap().apply {
+                            putString("event", event.name)
+                            putString("message", message ?: "Unknown error")
+                        }
+                    sendEvent("onLivenessError", errorMap)
+                    promise.reject(event.name, message ?: "Unknown Liveness error")
+                }
+            )
+        } catch (e: Exception) {
+            Log.e(TAG, "Exception in startLiveness: ${e.message}", e)
+            promise.reject("LIVENESS_ERROR", e.message)
+        }
+    }
+
+    @ReactMethod
+    fun startFaceCompare(
+        appKey: String,
+        transactionId: String,
+        selfieImage: String,
+        idImage: String,
+        promise: Promise
+    ) {
+        try {
+            val currentActivity = reactApplicationContext.currentActivity
+            if (currentActivity == null) {
+                promise.reject("NO_ACTIVITY", "Activity not available")
+                return
+            }
+            val imageFile = File(selfieImage.replace("file://", ""))
+            if (!imageFile.exists()) {
+                promise.reject("FILE_NOT_FOUND", "Image file does not exist")
+                return
+            }
+            val idImageFile = base64ToImageFile(idImage)
+
+            val faceServiceConfig =
+                FaceServiceConfig(
+                    appKey = appKey,
+                    transactionId = transactionId,
+                    selfieImage = imageFile,
+                    idImage = idImageFile
+                )
+            val ekycConfig = EKYCConfigSDK(faceServiceConfig = faceServiceConfig)
+            SdkEkycFaceService.startEkyc(
+                ekycConfigSDK = ekycConfig,
+                callbackSuccess = { event, data ->
+                    Log.d(TAG, "Face Compare Success - Event: $event, Data: $data")
+                    val resultMap =
+                        Arguments.createMap().apply {
+                            putString("event", event.name)
+                            putString("data", data.toString())
+                        }
+                    sendEvent("onFaceCompareSuccess", resultMap)
+                    val promiseMap =
+                        Arguments.createMap().apply {
+                            putString("event", event.name)
+                            putString("data", data.toString())
+                        }
+                    promise.resolve(promiseMap)
+                },
+                callbackError = { event, message ->
+                    Log.e(TAG, "FaceService Error - Event: $event, Message: $message")
+                    val errorMap =
+                        Arguments.createMap().apply {
+                            putString("event", event.name)
+                            putString("message", message ?: "Unknown error")
+                        }
+                    sendEvent("onFaceCompareError", errorMap)
+                    promise.reject(event.name, message ?: "Unknown FaceService error")
+                }
+            )
+        } catch (e: Exception) {
+            Log.e(TAG, "Exception in startFaceCompare: ${e.message}", e)
+            promise.reject("FACE_COMPARE_ERROR", e.message)
+        }
+    }
+
+    @ReactMethod
+    fun onResume() {
+        reactApplicationContext.currentActivity?.let { activity ->
+            activity.runOnUiThread { SdkEkycNfc.onResumeNfc(activity) }
+        }
+    }
+
+    @ReactMethod
+    fun onPause() {
+        reactApplicationContext.currentActivity?.let { activity ->
+            activity.runOnUiThread { SdkEkycNfc.onPauseNfc(activity) }
+        }
+    }
+
+    @ReactMethod
+    fun handleNewIntent() {
+        reactApplicationContext.currentActivity?.let { activity ->
+            activity.runOnUiThread { SdkEkycNfc.onNewIntentNfc(activity.intent) }
+        }
+    }
+
+    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
+        }
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@finos_sdk/sdk-ekyc",
-  "version": "0.0.22",
+  "version": "0.0.23",
   "description": "SDK React Native EKYC",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",