@finos_sdk/sdk-ekyc 0.0.36 → 0.0.37

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,17 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    package="finos.sdk.ekyc">
+
+    <application/>
+
+</manifest>
+
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    package="finos.sdk.ekyc">
+
+    <!-- Library manifest. No application/components are required here. -->
+
+</manifest>
+
+
+

package/android/src/main/build.gradle

@@ -0,0 +1,39 @@
+plugins {
+    id 'com.android.library'
+    id 'org.jetbrains.kotlin.android'
+}
+
+android {
+    namespace 'finos.sdk.ekyc'
+    compileSdk rootProject.ext.compileSdkVersion
+
+    defaultConfig {
+        minSdkVersion rootProject.ext.minSdkVersion
+        targetSdkVersion rootProject.ext.targetSdkVersion
+        consumerProguardFiles 'consumer-rules.pro'
+    }
+
+    buildTypes {
+        release {
+            minifyEnabled false
+            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
+        }
+    }
+}
+
+dependencies {
+    implementation 'com.facebook.react:react-android'
+    implementation("finos.sdk.ekyc:ekyc:1.2.0")
+    implementation("finos.sdk.ekyc:ekycui:1.2.0")
+    implementation("finos.sdk.ekyc:nfc:1.2.0")
+    implementation("finos.sdk.ekyc:ocr:1.2.0")
+    implementation("finos.sdk.ekyc:liveness:1.2.0")
+    implementation("finos.sdk.ekyc:faceservice:1.2.0")
+    implementation("finos.sdk.ekyc:c06:1.2.0")
+    implementation("finos.sdk.ekyc:sdkcore:1.2.0")
+    implementation("finos.sdk.ekyc:sdkcorecamera:1.2.0")
+    implementation("finos.sdk.ekyc:sdkui:1.2.0")
+    implementation("finos.sdk.ekyc:qrcode:1.2.0")
+}
+
+

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

@@ -0,0 +1,541 @@
+// ... 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
+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.AppKeyConfig
+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.core.model.sdk.config.OptionConfig
+import finos.sdk.core.model.sdk.config.StyleConfig
+import finos.sdk.core.define.AppIDType
+import finos.sdk.ekyc.SdkEkyc
+import finos.sdk.ekyc.ui.SdkEkycUI
+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(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) {
+
+    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}")
+        }
+    }
+
+    @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")
+
+                    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 {
+            var processedBase64 = base64Image
+            if (base64Image.contains(",")) {
+                processedBase64 = base64Image.split(",")[1]
+            }
+
+            val bytes = Base64.decode(processedBase64, Base64.DEFAULT)
+            val timestamp = Date().time.toString()
+            val fileName = "image_$timestamp.jpg"
+            val directory = reactApplicationContext.cacheDir
+            val filePath = "${directory.path}/$fileName"
+            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)
+            val errorFile = File(reactApplicationContext.cacheDir, "error_image_${Date().time}.jpg")
+            errorFile.createNewFile()
+            return errorFile
+        }
+    }
+}
+
+

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

@@ -0,0 +1,38 @@
+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 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.35";
+export declare const SDK_VERSION = "0.0.36";
 export declare const SDK_NAME = "@finos_sdk/sdk-ekyc";
 declare class SDKeKYC {
     private eventEmitter;

package/dist/EKYCModule.js

@@ -3,7 +3,7 @@ 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.35';
+exports.SDK_VERSION = '0.0.36';
 exports.SDK_NAME = '@finos_sdk/sdk-ekyc';
 const EKYCNativeModule = react_native_1.NativeModules.EKYCModule;
 // Validate that the module is available

package/package.json

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