@oiti/rn-liveness3d 3.4.0 → 5.0.0

package/android/build.gradle

@@ -1,48 +1,44 @@
 buildscript {
-  // Buildscript is evaluated before everything else so we can't use getExtOrDefault
-  def kotlin_version = rootProject.ext.has('kotlinVersion') ? rootProject.ext.get('kotlinVersion') : project.properties['RnLiveness3d_kotlinVersion']
+  ext.getExtOrDefault = {name ->
+    return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties['RnLiveness3d_' + name]
+  }
 
   repositories {
-      google()
-      mavenCentral()
-      maven {
-        url 'https://raw.githubusercontent.com/oititec/android-oiti-versions/master'
-      }
+    google()
+    mavenCentral()
   }
 
   dependencies {
-    classpath 'com.android.tools.build:gradle:3.5.3'
-    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
+    classpath "com.android.tools.build:gradle:8.1.1"
+    // noinspection DifferentKotlinGradleVersion
+    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:${getExtOrDefault('kotlinVersion')}"
   }
 }
 
-def isNewArchitectureEnabled() {
-  return rootProject.hasProperty("newArchEnabled") &&  rootProject.getProperty("newArchEnabled") == "true"
-}
-
-apply plugin: 'com.android.library'
-apply plugin: 'kotlin-android'
 
-if (isNewArchitectureEnabled()) {
-  apply plugin: 'com.facebook.react'
-}
+apply plugin: "com.android.library"
+apply plugin: "kotlin-android"
 
-def getExtOrDefault(name) {
-  return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties['RnLiveness3d_' + name]
-}
+apply plugin: "com.facebook.react"
 
 def getExtOrIntegerDefault(name) {
-  return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties['RnLiveness3d_' + name]).toInteger()
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["RnLiveness3d_" + name]).toInteger()
 }
 
 android {
-  compileSdkVersion getExtOrIntegerDefault('compileSdkVersion')
+  namespace "br.com.oiti.rnliveness3d"
+
+  compileSdkVersion getExtOrIntegerDefault("compileSdkVersion")
 
   defaultConfig {
-    minSdkVersion getExtOrIntegerDefault('minSdkVersion')
-    targetSdkVersion getExtOrIntegerDefault('targetSdkVersion')
-    buildConfigField "boolean", "IS_NEW_ARCHITECTURE_ENABLED", isNewArchitectureEnabled().toString()
+    minSdkVersion getExtOrIntegerDefault("minSdkVersion")
+    targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
   }
+
+  buildFeatures {
+    buildConfig true
+  }
+
   buildTypes {
     release {
       minifyEnabled false
@@ -50,104 +46,40 @@ android {
   }
 
   lintOptions {
-    disable 'GradleCompatible'
+    disable "GradleCompatible"
   }
 
   compileOptions {
     sourceCompatibility JavaVersion.VERSION_1_8
     targetCompatibility JavaVersion.VERSION_1_8
   }
-  buildToolsVersion '34.0.0'
 
+  sourceSets {
+    main {
+      java.srcDirs += [
+        "generated/java",
+        "generated/jni"
+      ]
+    }
+  }
 }
 
 repositories {
-  google()
   mavenCentral()
-  maven { url "https://raw.githubusercontent.com/oititec/android-oiti-versions/master" }
-
-  def found = false
-  def defaultDir = null
-  def androidSourcesName = 'React Native sources'
-
-  if (rootProject.ext.has('reactNativeAndroidRoot')) {
-    defaultDir = rootProject.ext.get('reactNativeAndroidRoot')
-  } else {
-    defaultDir = new File(
-      projectDir,
-      '/../../../node_modules/react-native/android'
-    )
-  }
-
-  if (defaultDir.exists()) {
-    maven {
-      url defaultDir.toString()
-      name androidSourcesName
-    }
-
-    logger.info(":${project.name}:reactNativeAndroidRoot ${defaultDir.canonicalPath}")
-    found = true
-  } else {
-    def parentDir = rootProject.projectDir
-
-    1.upto(5, {
-      if (found) return true
-      parentDir = parentDir.parentFile
-
-      def androidSourcesDir = new File(
-        parentDir,
-        'node_modules/react-native'
-      )
-
-      def androidPrebuiltBinaryDir = new File(
-        parentDir,
-        'node_modules/react-native/android'
-      )
-
-      if (androidPrebuiltBinaryDir.exists()) {
-        maven {
-          url androidPrebuiltBinaryDir.toString()
-          name androidSourcesName
-        }
-
-        logger.info(":${project.name}:reactNativeAndroidRoot ${androidPrebuiltBinaryDir.canonicalPath}")
-        found = true
-      } else if (androidSourcesDir.exists()) {
-        maven {
-          url androidSourcesDir.toString()
-          name androidSourcesName
-        }
-
-        logger.info(":${project.name}:reactNativeAndroidRoot ${androidSourcesDir.canonicalPath}")
-        found = true
-      }
-    })
-  }
-
-  if (!found) {
-    throw new GradleException(
-      "${project.name}: unable to locate React Native android sources. " +
-      "Ensure you have you installed React Native as a dependency in your project and try again."
-    )
-  }
+  google()
 }
 
-def kotlin_version = getExtOrDefault('kotlinVersion')
+def kotlin_version = getExtOrDefault("kotlinVersion")
 
 dependencies {
-    //noinspection GradleDynamicVersion
-  implementation "com.facebook.react:react-native:+"
+  implementation "com.facebook.react:react-android"
   implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
 
-  implementation 'br.com.oiti:liveness3d-sdk:9.4.7'
-
-// From node_modules
+  implementation 'br.com.oiti:liveness3d-sdk:9.5.2'
 }
 
-if (isNewArchitectureEnabled()) {
-  react {
-    jsRootDir = file("../src/")
-    libraryName = "RnLiveness3d"
-    codegenJavaPackageName = "br.com.oiti.rnliveness3d"
-  }
+react {
+  jsRootDir = file("../src/")
+  libraryName = "RnLiveness3d"
+  codegenJavaPackageName = "br.com.oiti.rnliveness3d"
 }

package/android/gradle.properties

@@ -1,5 +1,5 @@
-RnLiveness3d_kotlinVersion=1.7.0
-RnLiveness3d_minSdkVersion=21
-RnLiveness3d_targetSdkVersion=31
-RnLiveness3d_compileSdkVersion=31
-RnLiveness3d_ndkversion=21.4.7075529
+RnLiveness3d_kotlinVersion=2.1.20
+RnLiveness3d_minSdkVersion=24
+RnLiveness3d_targetSdkVersion=36
+RnLiveness3d_compileSdkVersion=36
+RnLiveness3d_ndkversion=27.1.12297006

package/android/src/main/AndroidManifest.xml

@@ -1,9 +1,2 @@
-<manifest xmlns:android="http://schemas.android.com/apk/res/android"
-          package="br.com.oiti.rnliveness3d">
-
-  <uses-permission android:name="android.permission.INTERNET" />
-  <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
-  <uses-permission android:name="android.permission.CAMERA" />
-  <uses-permission android:name="android.permission.READ_PHONE_STATE" />
-
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
 </manifest>

package/android/src/main/java/br/com/oiti/rnliveness3d/RnLiveness3dModule.kt

@@ -1,221 +1,247 @@
-  package br.com.oiti.rnliveness3d
-
-  import android.Manifest
-  import android.app.Activity
-  import android.content.Intent
-  import android.content.pm.PackageManager
-  import android.util.Log
-  import androidx.annotation.NonNull
-  import androidx.core.app.ActivityCompat
-  import androidx.core.content.*
-
-  import br.com.oiti.liveness3d.app.ui.HybridLiveness3DActivity
-  import br.com.oiti.rnliveness3d.theme.Liveness3DTheme
-
-  import br.com.oiti.liveness3d.data.model.*
-  import br.com.oiti.rnliveness3d.theme.Liveness3DText
-
-  import com.facebook.react.bridge.*
-  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.modules.core.PermissionAwareActivity
-  import org.json.JSONObject
-
-  class RnLiveness3dModule(reactContext: ReactApplicationContext) :
-    ReactContextBaseJavaModule(reactContext) {
-
-    private var mLiveness3dPromisse: Promise? = null
-
-    init {
-      reactContext.addActivityEventListener(object : BaseActivityEventListener() {
-        override fun onActivityResult(activity: Activity, requestCode: Int, resultCode: Int, data: Intent?) {
-          if (requestCode == LIVENESS3D_REQUEST && mLiveness3dPromisse != null) {
-            when (resultCode) {
-              Activity.RESULT_CANCELED -> mLiveness3dPromisse!!.reject(RESULT_CANCELED,onLiveness3DResultCancelled(data))
-              Activity.RESULT_OK -> mLiveness3dPromisse!!.resolve(onLiveness3DResultSuccess(data))
-            }
-            mLiveness3dPromisse = null
-          }
-        }
-      })
-    }
+package br.com.oiti.rnliveness3d
+
+import android.Manifest
+import android.app.Activity
+import android.content.Intent
+import android.content.pm.PackageManager
+import android.util.Log
+import androidx.core.app.ActivityCompat
+import androidx.core.content.ContextCompat
+import br.com.oiti.liveness3d.app.ui.HybridLiveness3DActivity
+import br.com.oiti.liveness3d.data.model.ENVIRONMENT3D
+import br.com.oiti.liveness3d.data.model.Liveness3DFontsKey
+import br.com.oiti.liveness3d.data.model.Liveness3DUser
+import br.com.oiti.liveness3d.data.model.LoadingType3D
+import br.com.oiti.rnliveness3d.theme.Liveness3DText
+import br.com.oiti.rnliveness3d.theme.Liveness3DTheme
+import com.facebook.react.bridge.BaseActivityEventListener
+import com.facebook.react.bridge.Callback
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.module.annotations.ReactModule
+import org.json.JSONObject
+
+@ReactModule(name = RnLiveness3dModule.NAME)
+class RnLiveness3dModule(reactContext: ReactApplicationContext) :
+  NativeRnLiveness3dSpec(reactContext) {
+  private var liveness3dPromise: Promise? = null
+  private var cameraPermissionCallback: Callback? = null
+
+  init {
+    reactContext.addActivityEventListener(object : BaseActivityEventListener() {
+      override fun onActivityResult(
+        activity: Activity,
+        requestCode: Int,
+        resultCode: Int,
+        data: Intent?
+      ) {
+        handleActivityResult(requestCode = requestCode, resultCode = resultCode, data = data)
+      }
+    })
+  }
 
-    fun onLiveness3DResultSuccess(data: Intent?): String {
-      val resultMap = mutableMapOf<String, Any?>()
+  /**
+   * Spec methods
+   */
 
-      resultMap["valid"] = data?.getBooleanExtra(HybridLiveness3DActivity.PARAM_RESULT_VALID, false)
-      resultMap["cause"] = data?.getStringExtra(HybridLiveness3DActivity.PARAM_RESULT_CAUSE)
-      resultMap["codId"] = data?.getStringExtra(HybridLiveness3DActivity.PARAM_RESULT_COD_ID)
-      resultMap["protocol"] = data?.getStringExtra(HybridLiveness3DActivity.PARAM_RESULT_PROTOCOL)
-      resultMap["blob"] = data?.getStringExtra(HybridLiveness3DActivity.PARAM_RESULT_SCAN)
+  override fun getName(): String {
+    return NAME
+  }
 
-      return JSONObject(resultMap).toString()
-    }
+  override fun checkCameraPermissionGranted(): Boolean {
+    val permission =
+      ContextCompat.checkSelfPermission(reactApplicationContext, Manifest.permission.CAMERA)
+    return permission == PackageManager.PERMISSION_GRANTED
+  }
 
-    fun onLiveness3DResultCancelled(data: Intent?): String {
-      return data?.getStringExtra(HybridLiveness3DActivity.PARAM_RESULT_ERROR) ?: ""
+  override fun requestCameraPermission(resolve: Callback?) {
+    val activity = reactApplicationContext.currentActivity ?: run {
+      resolve?.invoke(false)
+      return
     }
-    override fun getName(): String {
-      return NAME
+
+    val permissionGranted = checkCameraPermissionGranted()
+    if (permissionGranted) {
+      resolve?.invoke(true)
+      return
     }
-    @NonNull
-    @ReactMethod
-    fun startliveness3d(
-      appKey: String,
-      ticket: String,
-      type: String,
-      size: Int,
-      backgroundColor: String,
-      loadingColor: String,
-      themeJson: ReadableMap?,
-      fontsJson: ReadableMap?,
-      textsJson: ReadableMap?,
-      environment: String,
-      promise: Promise,
-    ) {
-      mLiveness3dPromisse = promise
-      val currentActivity = currentActivity
-
-      val themeBuilder = themeJson?.let { Liveness3DTheme(readableMapToMap(themeJson)).apply() }
-      val fonts = fontsJson?.let { getFonts(readableMapToMap(fontsJson)) }
-      val texts = textsJson?.let { Liveness3DText().getTexts(readableMapToMap(textsJson)) }
-
-      Log.d("ENV", environment)
-
-      if (currentActivity == null) {
-        promise.reject(E_ACTIVITY_DOES_NOT_EXIST, "Activity doesn't exist")
-        return;
-      }
-        try {
-          val env: ENVIRONMENT3D = if (environment.equals("PRD")) ENVIRONMENT3D.PRD else ENVIRONMENT3D.HML
-          val liveness3DUser = Liveness3DUser(appKey = appKey, env, themeBuilder)
-
-          val intent = Intent(currentActivity, HybridLiveness3DActivity::class.java).apply {
-            putExtra(HybridLiveness3DActivity.PARAM_LIVENESS3D_USER, liveness3DUser)
-            if (ticket.isNotEmpty()) {
-              putExtra(HybridLiveness3DActivity.PARAM_TICKET, ticket)
-            }
-            putExtra(HybridLiveness3DActivity.PARAM_TEXTS, texts)
-            putExtra(HybridLiveness3DActivity.PARAM_FONTS, fonts)
-            putExtra(HybridLiveness3DActivity.PARAM_CUSTOM_LOADING_BACKGROUND, backgroundColor)
-            putExtra(HybridLiveness3DActivity.PARAM_CUSTOM_LOADING_SPINNER_COLOR, loadingColor)
-            putExtra(HybridLiveness3DActivity.PARAM_CUSTOM_LOADING_SIZE, size)
-            if(type == "default"){
-              putExtra(HybridLiveness3DActivity.PARAM_CUSTOM_LOADING_TYPE, LoadingType3D.ACTIVITY_INDICATOR)
-            }else{
-              putExtra(HybridLiveness3DActivity.PARAM_CUSTOM_LOADING_TYPE, LoadingType3D.SPINNER)
-            }
-          }
 
-          currentActivity.startActivityForResult(intent, LIVENESS3D_REQUEST)
+    ActivityCompat.requestPermissions(
+      activity,
+      arrayOf(Manifest.permission.CAMERA),
+      CAMERA_PERMISSION_REQUEST_CODE
+    )
+    resolve?.invoke(false)
+  }
 
-        } catch (e: Exception) {
-          Log.d("APPKEY_FAILED", appKey)
-          mLiveness3dPromisse?.reject(E_FAILED_TO_SHOW_PICKER, e)
-          mLiveness3dPromisse = null
-        }
+  override fun startLiveness3d(args: ReadableMap?, promise: Promise?) {
+    liveness3dPromise = promise
+
+    val currentActivity = reactApplicationContext.currentActivity ?: run {
+      promise?.reject(E_ACTIVITY_DOES_NOT_EXIST, "Activity doesn't exist")
+      return
     }
 
-    fun readableMapToMap(readableMap: ReadableMap?): Map<String, String?> {
-      val map = mutableMapOf<String, String?>()
-      readableMap?.let {
-        val iterator = it.keySetIterator()
-        while (iterator.hasNextKey()) {
-          val key = iterator.nextKey()
-          val value = it.getString(key)
-          map[key] = value
-        }
+    val appKey = args?.getString(name = "appkey") ?: ""
+    val environmentString = args?.getString(name = "environment") ?: "HML"
+    val themeMap = args?.getMap(name = "theme")
+    val fontsMap = args?.getMap(name = "fonts")
+    val textsMap = args?.getMap(name = "liveness3Dtext")
+    val loadingMap = args?.getMap(name = "loading")
+
+    val themeBuilder = themeMap?.let { Liveness3DTheme(readableMapToMap(it)).apply() }
+    val fonts = fontsMap?.let { getFonts(readableMapToMap(it)) }
+    val texts = textsMap?.let { Liveness3DText().getTexts(readableMapToMap(it)) }
+
+    val loadingTypeString = loadingMap?.getString(name = "type") ?: "default"
+    val loadingType =
+      if (loadingTypeString == "default") LoadingType3D.ACTIVITY_INDICATOR else LoadingType3D.SPINNER
+    val loadingColor = loadingMap?.getString(name = "loadingColor") ?: "#000000"
+    val loadingBackground = loadingMap?.getString(name = "backgroundColor") ?: "#FFFFFF"
+    val loadingSize = when(loadingMap?.hasKey(name = "size")) {
+      true -> loadingMap.getInt(name = "size")
+      else -> 10
+    }
+
+    Log.d("ENV", environmentString)
+    Log.d("ENV", appKey)
+
+    try {
+      val environment = if (environmentString == "PRD") ENVIRONMENT3D.PRD else ENVIRONMENT3D.HML
+      val liveness3DUser = Liveness3DUser(
+        appKey = appKey,
+        environment = environment,
+        liveness3DTheme = themeBuilder
+      )
+
+      val intent = Intent(currentActivity, HybridLiveness3DActivity::class.java).apply {
+        putExtra(HybridLiveness3DActivity.PARAM_LIVENESS3D_USER, liveness3DUser)
+        putExtra(HybridLiveness3DActivity.PARAM_TEXTS, texts)
+        putExtra(HybridLiveness3DActivity.PARAM_FONTS, fonts)
+
+        putExtra(HybridLiveness3DActivity.PARAM_CUSTOM_LOADING_TYPE, loadingType)
+        putExtra(HybridLiveness3DActivity.PARAM_CUSTOM_LOADING_SPINNER_COLOR, loadingColor)
+        putExtra(HybridLiveness3DActivity.PARAM_CUSTOM_LOADING_BACKGROUND, loadingBackground)
+        putExtra(HybridLiveness3DActivity.PARAM_CUSTOM_LOADING_SIZE, loadingSize)
       }
-      return map
+
+      currentActivity.startActivityForResult(intent, LIVENESS3D_REQUEST)
+    } catch (e: Exception) {
+      Log.d("APPKEY_FAILED", appKey)
+      liveness3dPromise?.reject(E_FAILED_TO_SHOW_PICKER, e)
+      liveness3dPromise = null
     }
+  }
 
-    private fun getFonts(fontsBuilder: Map<String, String?>?): HashMap<Liveness3DFontsKey?, String?> {
-      val hashMap = HashMap<Liveness3DFontsKey?, String?>()
-      if (fontsBuilder != null) {
-        val fontsMap = fontsBuilder
-          .mapNotNull {
-            val key = getFontKey(it.key)
-            val value = it.value
-            if (value?.isEmpty() == true) {
-              null
-            } else { Pair(key, "fonts/$value.ttf".lowercase()) }
+  /**
+   * Private methods
+   */
+
+  private fun handleActivityResult(
+    requestCode: Int,
+    resultCode: Int,
+    data: Intent?
+  ) {
+    when (requestCode) {
+      LIVENESS3D_REQUEST -> {
+        liveness3dPromise?.let {
+          when (resultCode) {
+            Activity.RESULT_OK -> it.resolve(onLivenessSuccess(data))
+            Activity.RESULT_CANCELED -> it.reject(RESULT_CANCELED, onLivenessCancelled(data))
           }
-          .toMap()
-        hashMap.putAll(fontsMap)
+          liveness3dPromise = null
+        }
       }
-      return hashMap
-    }
 
-    private fun getFontKey(identifier: String): Liveness3DFontsKey? {
-      return when(identifier) {
-        /* Guidance */
-        "guidanceCustomizationHeaderFont" -> Liveness3DFontsKey.GUIDANCE_CUSTOMIZATION_HEADER_FONT
-        "guidanceCustomizationSubtextFont" -> Liveness3DFontsKey.GUIDANCE_CUSTOMIZATION_SUBTEXT_FONT
-        /* Button */
-        "guidanceCustomizationButtonFont" -> Liveness3DFontsKey.GUIDANCE_CUSTOMIZATION_BUTTON_FONT
-
-        /* Ready Screen */
-        "readyScreenCustomizationHeaderFont" -> Liveness3DFontsKey.GUIDANCE_CUSTOMIZATION_READY_SCREEN_HEADER_FONT
-        "readyScreenCustomizationSubtextFont" -> Liveness3DFontsKey.GUIDANCE_CUSTOMIZATION_READY_SCREEN_SUBTEXT_FONT
-        /* Retry Screen */
-        "retryScreenCustomizationHeaderFont" -> Liveness3DFontsKey.GUIDANCE_CUSTOMIZATION_RETRY_SCREEN_HEADER_FONT
-        "retryScreenCustomizationSubtextFont" -> Liveness3DFontsKey.GUIDANCE_CUSTOMIZATION_RETRY_SCREEN_SUBTEXT_FONT
-        /* Result Screen */
-        "resultScreenCustomizationMessageFont" -> Liveness3DFontsKey.RESULT_SCREEN_CUSTOMIZATION_MESSAGE_FONT
-        /* Feedback */
-        "feedbackCustomizationTextFont" -> Liveness3DFontsKey.FEEDBACK_CUSTOMIZATION_TEXT_FONT
-        else -> null
+      CAMERA_PERMISSION_REQUEST_CODE -> {
+        cameraPermissionCallback?.let {
+          when (resultCode) {
+            Activity.RESULT_OK -> it.invoke(checkCameraPermissionGranted())
+            Activity.RESULT_CANCELED -> it.invoke(false)
+          }
+          cameraPermissionCallback = null
+        }
       }
     }
+  }
 
-    @ReactMethod
-    fun checkcamerapermission(promise: Promise) {
-      val currentActivity = currentActivity
-      if (currentActivity != null) {
-        if (ContextCompat.checkSelfPermission(currentActivity, Manifest.permission.CAMERA) == PackageManager.PERMISSION_GRANTED) {
-          promise.resolve(true)
-        } else {
-          promise.resolve(false)
-        }
-      } else {
-        promise.reject("UNAVAILABLE", "Could not get current activity.")
+  private fun onLivenessSuccess(data: Intent?): String {
+    val resultMap = mutableMapOf<String, Any?>()
+
+    resultMap["valid"] = data?.getBooleanExtra(HybridLiveness3DActivity.PARAM_RESULT_VALID, false)
+    resultMap["cause"] = data?.getStringExtra(HybridLiveness3DActivity.PARAM_RESULT_CAUSE)
+    resultMap["codId"] = data?.getStringExtra(HybridLiveness3DActivity.PARAM_RESULT_COD_ID)
+    resultMap["protocol"] = data?.getStringExtra(HybridLiveness3DActivity.PARAM_RESULT_PROTOCOL)
+    resultMap["blob"] = data?.getStringExtra(HybridLiveness3DActivity.PARAM_RESULT_SCAN)
+
+    return JSONObject(resultMap).toString()
+  }
+
+  private fun onLivenessCancelled(data: Intent?): String {
+    return data?.getStringExtra(HybridLiveness3DActivity.PARAM_RESULT_ERROR) ?: ""
+  }
+
+  private fun readableMapToMap(readableMap: ReadableMap?): Map<String, String?> {
+    val map = mutableMapOf<String, String?>()
+    readableMap?.let {
+      val iterator = it.keySetIterator()
+      while (iterator.hasNextKey()) {
+        val key = iterator.nextKey()
+        val value = it.getString(key)
+        map[key] = value
       }
     }
+    return map
+  }
 
-    @ReactMethod
-    fun askcamerapermission(promise: Promise) {
-      val currentActivity = currentActivity
-
-      if (currentActivity != null) {
-        if (ContextCompat.checkSelfPermission(currentActivity, Manifest.permission.CAMERA)
-          == PackageManager.PERMISSION_GRANTED
-        ) {
-          promise.resolve(true)
-        } else {
-          if (currentActivity is PermissionAwareActivity) {
-            ActivityCompat.requestPermissions(
-              currentActivity,
-              arrayOf(Manifest.permission.CAMERA),
-              CAMERA_PERMISSION_REQUEST_CODE
-            )
+  private fun getFonts(fontsBuilder: Map<String, String?>?): HashMap<Liveness3DFontsKey?, String?> {
+    val hashMap = HashMap<Liveness3DFontsKey?, String?>()
+    if (fontsBuilder != null) {
+      val fontsMap = fontsBuilder
+        .mapNotNull {
+          val key = getFontKey(it.key)
+          val value = it.value
+          if (value?.isEmpty() == true) {
+            null
           } else {
-            promise.resolve(false)
+            Pair(key, "fonts/$value.ttf".lowercase())
           }
-          promise.resolve(false)
         }
-      } else {
-        promise.resolve(true)
-      }
+        .toMap()
+      hashMap.putAll(fontsMap)
     }
+    return hashMap
+  }
 
-    companion object {
-      const val NAME = "RnLiveness3d"
-        const val CAMERA_PERMISSION_REQUEST_CODE = 1111
-        private const val LIVENESS3D_REQUEST = 1
-        private const val E_ACTIVITY_DOES_NOT_EXIST = "E_ACTIVITY_DOES_NOT_EXIST"
-        private const val E_FAILED_TO_SHOW_PICKER = "E_FAILED_TO_SHOW_PICKER"
-        private val RESULT_CANCELED = "RESULT_CANCELED"
+  private fun getFontKey(identifier: String): Liveness3DFontsKey? {
+    return when (identifier) {
+      /* Guidance */
+      "guidanceCustomizationHeaderFont" -> Liveness3DFontsKey.GUIDANCE_CUSTOMIZATION_HEADER_FONT
+      "guidanceCustomizationSubtextFont" -> Liveness3DFontsKey.GUIDANCE_CUSTOMIZATION_SUBTEXT_FONT
+      /* Button */
+      "guidanceCustomizationButtonFont" -> Liveness3DFontsKey.GUIDANCE_CUSTOMIZATION_BUTTON_FONT
+
+      /* Ready Screen */
+      "readyScreenCustomizationHeaderFont" -> Liveness3DFontsKey.GUIDANCE_CUSTOMIZATION_READY_SCREEN_HEADER_FONT
+      "readyScreenCustomizationSubtextFont" -> Liveness3DFontsKey.GUIDANCE_CUSTOMIZATION_READY_SCREEN_SUBTEXT_FONT
+      /* Retry Screen */
+      "retryScreenCustomizationHeaderFont" -> Liveness3DFontsKey.GUIDANCE_CUSTOMIZATION_RETRY_SCREEN_HEADER_FONT
+      "retryScreenCustomizationSubtextFont" -> Liveness3DFontsKey.GUIDANCE_CUSTOMIZATION_RETRY_SCREEN_SUBTEXT_FONT
+      /* Result Screen */
+      "resultScreenCustomizationMessageFont" -> Liveness3DFontsKey.RESULT_SCREEN_CUSTOMIZATION_MESSAGE_FONT
+      /* Feedback */
+      "feedbackCustomizationTextFont" -> Liveness3DFontsKey.FEEDBACK_CUSTOMIZATION_TEXT_FONT
+      else -> null
     }
   }
+
+  companion object {
+    const val NAME = "RnLiveness3d"
+    private const val CAMERA_PERMISSION_REQUEST_CODE = 100
+    private const val LIVENESS3D_REQUEST = 1
+    private const val RESULT_CANCELED = "RESULT_CANCELED"
+    private const val E_ACTIVITY_DOES_NOT_EXIST = "E_ACTIVITY_DOES_NOT_EXIST"
+    private const val E_FAILED_TO_SHOW_PICKER = "E_FAILED_TO_SHOW_PICKER"
+  }
+}