@certiface/sdk 1.0.0

package/RnSdk.podspec

@@ -0,0 +1,27 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+
+Pod::Spec.new do |s|
+  s.name         = "RnSdk"
+  s.version      = package["version"]
+  s.summary      = package["description"]
+  s.homepage     = package["homepage"]
+  s.license      = package["license"]
+  s.authors      = package["author"]
+
+  s.platforms    = { :ios => min_ios_version_supported }
+  s.source       = { :git => "https://github.com/oititec/certiface-sdk-rn.git", :tag => "#{s.version}" }
+
+  s.source_files = "ios/**/*.{h,m,mm,cpp,swift}"
+  s.resource_bundles = {
+    'RnSdkBundle' => ['ios/Resources/**/*.xcassets']
+  }
+  s.private_header_files = "ios/**/*.h"
+
+  s.frameworks = "AVFoundation"
+  
+  s.dependency 'CertifaceSDK', '1.2.0'
+
+  install_modules_dependencies(s)
+end

package/android/build.gradle

@@ -0,0 +1,86 @@
+buildscript {
+  ext.getExtOrDefault = {name ->
+    return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties['RnSdk_' + name]
+  }
+
+  repositories {
+    google()
+    mavenCentral()
+  }
+
+  dependencies {
+    classpath "com.android.tools.build:gradle:8.9.1"
+    // noinspection DifferentKotlinGradleVersion
+    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:${getExtOrDefault('kotlinVersion')}"
+  }
+}
+
+
+apply plugin: "com.android.library"
+apply plugin: "kotlin-android"
+
+apply plugin: "com.facebook.react"
+
+def getExtOrIntegerDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["RnSdk_" + name]).toInteger()
+}
+
+android {
+  namespace "br.com.oititec.rn.sdk"
+
+  compileSdkVersion getExtOrIntegerDefault("compileSdkVersion")
+
+  defaultConfig {
+    minSdkVersion getExtOrIntegerDefault("minSdkVersion")
+    targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
+  }
+
+  buildFeatures {
+    buildConfig true
+  }
+
+  buildTypes {
+    release {
+      minifyEnabled false
+    }
+  }
+
+  lintOptions {
+    disable "GradleCompatible"
+  }
+
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_1_8
+    targetCompatibility JavaVersion.VERSION_1_8
+  }
+
+  sourceSets {
+    main {
+      java.srcDirs += [
+        "generated/java",
+        "generated/jni"
+      ]
+    }
+  }
+}
+
+repositories {
+  mavenLocal()
+  mavenCentral()
+  google()
+}
+
+def kotlin_version = getExtOrDefault("kotlinVersion")
+
+dependencies {
+  implementation "com.facebook.react:react-android"
+  implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+
+  implementation 'br.com.oiti:oitisdk:1.1.0'
+}
+
+react {
+  jsRootDir = file("../src/")
+  libraryName = "RnSdk"
+  codegenJavaPackageName = "br.com.oititec.rn.sdk"
+}

package/android/gradle.properties

@@ -0,0 +1,6 @@
+RnSdk_kotlinVersion=2.1.21
+RnSdk_minSdkVersion=26
+RnSdk_targetSdkVersion=35
+RnSdk_compileSdkVersion=36
+RnSdk_ndkVersion=27.1.12297006
+

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,2 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+</manifest>

package/android/src/main/java/br/com/oititec/rn/sdk/RnSdkModule.kt

@@ -0,0 +1,128 @@
+package br.com.oititec.rn.sdk
+
+import android.Manifest
+import android.content.pm.PackageManager
+import androidx.core.app.ActivityCompat
+import androidx.core.content.ContextCompat
+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.bridge.WritableMap
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.module.annotations.ReactModule
+import br.com.oititec.rn.sdk.executor.LivenessExecutor
+import br.com.oititec.rn.sdk.model.Features
+import org.json.JSONObject
+
+@ReactModule(name = RnSdkModule.NAME)
+class RnSdkModule(reactContext: ReactApplicationContext) :
+  NativeRnSdkSpec(reactContext) {
+
+  override fun getName(): String {
+    return NAME
+  }
+  override fun checkCameraPermission(promise: Promise?) {
+    val permission = ContextCompat.checkSelfPermission(reactApplicationContext, Manifest.permission.CAMERA)
+    promise?.resolve(permission == PackageManager.PERMISSION_GRANTED)
+  }
+
+  override fun requestCameraPermission(promise: Promise) {
+    val currentActivity = currentActivity
+    if (currentActivity == null) {
+      promise.reject("ERROR", "Activity is null")
+      return
+    }
+
+    val permission = ContextCompat.checkSelfPermission(currentActivity, Manifest.permission.CAMERA)
+    if (permission == PackageManager.PERMISSION_GRANTED) {
+      promise.resolve(true)
+      return
+    }
+
+    ActivityCompat.requestPermissions(currentActivity, arrayOf(Manifest.permission.CAMERA), CAMERA_PERMISSION_REQUEST_CODE)
+    promise.resolve(false)
+  }
+
+  override fun startJourney(
+    appKey: String?,
+    environment: String?,
+    provider: String?,
+    onSuccess: Callback?,
+    onError: Callback?,
+    isCustomEnabled: Boolean?,
+    theme: ReadableMap?
+  ) {
+    val customEnabled = isCustomEnabled ?: false
+
+    if (appKey.isNullOrEmpty()) {
+      onError?.invoke("APP_KEY_NULO")
+      return
+    }
+
+    if (environment.isNullOrEmpty()) {
+      onError?.invoke("ENVIRONMENT_NULO")
+      return
+    }
+
+    if (provider.isNullOrEmpty()) {
+      onError?.invoke("PROVIDER_NULO")
+      return
+    }
+
+    val selectedFeature = when (provider) {
+      "FACETEC" -> Features.Facetec
+      "IPROOV" -> Features.IProov
+      else -> {
+        onError?.invoke("PROVIDER_INVALIDO: $provider")
+        return
+      }
+    }
+
+    val activity = reactApplicationContext ?: run {
+      onError?.invoke("NO_ACTIVITY")
+      return
+    }
+
+    LivenessExecutor(appKey, selectedFeature).executeLiveness(
+      context = activity,
+      environment = environment,
+      execOnSuccess = { livenessResult ->
+        val jsonResult = convertLivenessResultToJson(livenessResult)
+        onSuccess?.invoke(jsonResult)
+      },
+      execOnError = { error ->
+        onError?.invoke(error)
+      },
+      isCustomEnabled = customEnabled,
+      theme = theme
+    )
+  }
+
+  private fun convertLivenessResultToJson(livenessResult: br.com.oiti.manager.exports.LivenessResult?): String {
+    return try {
+      val jsonObject = JSONObject()
+      jsonObject.put("status", "success")
+      
+      val resultObject = JSONObject()
+      resultObject.put("valid", livenessResult?.valid ?: false)
+      resultObject.put("codID", livenessResult?.codID ?: "")
+      resultObject.put("cause", livenessResult?.cause ?: "")
+      resultObject.put("protocol", livenessResult?.protocol ?: "")
+      resultObject.put("scanResultBlob", livenessResult?.scanResultBlob ?: "")
+      
+      jsonObject.put("result", resultObject)
+      jsonObject.toString()
+    } catch (e: Exception) {
+      val errorObject = JSONObject()
+      errorObject.put("status", "error")
+      errorObject.put("message", "Failed to serialize result: ${e.message}")
+      errorObject.toString()
+    }
+  }
+
+  companion object {
+    const val NAME = "RnSdk"
+    const val CAMERA_PERMISSION_REQUEST_CODE = 100
+  }
+}

package/android/src/main/java/br/com/oititec/rn/sdk/RnSdkPackage.kt

@@ -0,0 +1,33 @@
+package br.com.oititec.rn.sdk
+
+import com.facebook.react.BaseReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.model.ReactModuleInfo
+import com.facebook.react.module.model.ReactModuleInfoProvider
+import java.util.HashMap
+
+class RnSdkPackage : BaseReactPackage() {
+  override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? {
+    return if (name == RnSdkModule.NAME) {
+      RnSdkModule(reactContext)
+    } else {
+      null
+    }
+  }
+
+  override fun getReactModuleInfoProvider(): ReactModuleInfoProvider {
+    return ReactModuleInfoProvider {
+      val moduleInfos: MutableMap<String, ReactModuleInfo> = HashMap()
+      moduleInfos[RnSdkModule.NAME] = ReactModuleInfo(
+          RnSdkModule.NAME,
+          RnSdkModule.NAME,
+        false,
+        false,
+        false,
+        true
+      )
+      moduleInfos
+    }
+  }
+}

package/android/src/main/java/br/com/oititec/rn/sdk/executor/LivenessExevutor.kt

@@ -0,0 +1,66 @@
+package br.com.oititec.rn.sdk.executor
+
+import android.content.Context
+import br.com.oiti.domain.liveness.LivenessResponse
+import br.com.oiti.domain.model.ErrorResponse
+import br.com.oiti.manager.exports.Environment
+import br.com.oiti.manager.exports.LivenessResult
+import br.com.oiti.manager.exports.ResultCallback
+import br.com.oiti.manager.exports.SDKConfig
+import br.com.oiti.manager.main.CertifaceSDK
+import br.com.oititec.rn.sdk.model.Features
+import br.com.oititec.rn.sdk.strategy.FacetecStrategy
+import br.com.oititec.rn.sdk.strategy.IProovStrategy
+import br.com.oititec.rn.sdk.strategy.LivenessProviderStrategy
+import com.facebook.react.bridge.ReadableMap
+
+class LivenessExecutor(val appkey: String, val feature: Features) {
+
+  private val strategies: Map<Features, LivenessProviderStrategy> = mapOf(
+    Features.Facetec to FacetecStrategy(),
+    Features.IProov to IProovStrategy()
+  )
+
+  fun executeLiveness(
+    context: Context,
+    environment: String,
+    execOnSuccess: (LivenessResult?) -> Unit,
+    execOnError: (String?) -> Unit,
+    isCustomEnabled: Boolean = false,
+    theme: ReadableMap? = null
+  ) {
+    val sdkEnvironment = when (environment) {
+      "HML" -> Environment.HML
+      "PRD" -> Environment.PRD
+      else -> Environment.HML
+    }
+
+    CertifaceSDK.initialize(
+      context,
+      SDKConfig(
+        environment = sdkEnvironment,
+        appKey = appkey
+      )
+    )
+
+    val strategy = strategies[feature]
+      ?: error("Nenhuma strategy pra feature $feature")
+
+    val callback = object : ResultCallback<LivenessResult> {
+      override fun onSuccess(result: LivenessResponse) {
+        execOnSuccess(result.livenessResult)
+      }
+
+      override fun onError(result: LivenessResponse) {
+        val errorResponse = result.errorResponse
+        val errorMessage = if (errorResponse != null) {
+          "[${errorResponse.errorType}]: ${errorResponse.errorMessage}"
+        } else {
+          "Unknown error occurred"
+        }
+        execOnError(errorMessage)
+      }
+    }
+    strategy.start(context, appkey, isCustomEnabled, theme, callback)
+  }
+}

package/android/src/main/java/br/com/oititec/rn/sdk/factories/FacetecThemeFactory.kt

@@ -0,0 +1,233 @@
+package br.com.oititec.rn.sdk.factories
+
+import android.content.Context
+import br.com.oiti.designsystem.R
+import br.com.oiti.domain.model.facetec.FacetecButtonLocation
+import br.com.oiti.domain.model.facetec.FacetecExitAnimationStyle
+import br.com.oiti.domain.model.facetec.FacetecTheme
+import android.util.Log
+import br.com.oiti.manager.exports.FacetecFontsKey
+import br.com.oiti.manager.exports.FacetecTextKey
+import br.com.oititec.rn.sdk.theme.FacetecFonts
+import br.com.oititec.rn.sdk.processors.AssetProcessor
+import com.facebook.react.bridge.ReadableMap
+
+object FacetecThemeFactory {
+  private const val TAG = "FacetecThemeFactory"
+
+  fun buildDefault(): FacetecTheme = FacetecTheme.build {}
+
+  fun buildCustom(theme: ReadableMap? = null, context: Context? = null): FacetecTheme = FacetecTheme.build {
+    val instructionsTheme = theme?.getMap("instructions")
+    val instructionsColors = instructionsTheme?.getMap("colors")
+    val instructionsTexts = instructionsTheme?.getMap("texts")
+    val instructionsFonts = instructionsTheme?.getMap("fonts")
+    val instructionsConfiguration = instructionsTheme?.getMap("configuration")
+    val showInstructionScreen = instructionsConfiguration?.getBoolean("showInstructionScreen") ?: true
+
+    val permissionTheme = theme?.getMap("permission")
+    val permissionColors = permissionTheme?.getMap("colors")
+    val permissionTexts = permissionTheme?.getMap("texts")
+    val permissionFonts = permissionTheme?.getMap("fonts")
+
+    val facetecTheme = theme?.getMap("facetec")
+    val facetecColors = facetecTheme?.getMap("colors")
+    val facetecTexts = facetecTheme?.getMap("texts")
+    val facetecFontsMap = facetecTheme?.getMap("fonts")
+
+    val facetecFonts = if (facetecFontsMap != null) {
+      FacetecFonts(instructionsFonts, permissionFonts, facetecFontsMap).apply()
+    } else {
+      hashMapOf(
+        FacetecFontsKey.INSTRUCTIONS_TITLE_FONT to R.font.ubuntu_regular,
+        FacetecFontsKey.INSTRUCTIONS_CAPTION_FONT to R.font.ubuntu_regular,
+        FacetecFontsKey.INSTRUCTIONS_DOCUMENT_TYPES_INSTRUCTIONS_FONT to R.font.ubuntu_regular,
+        FacetecFontsKey.INSTRUCTIONS_DOCUMENT_TIPS_INSTRUCTIONS_FONT to R.font.ubuntu_regular,
+        FacetecFontsKey.INSTRUCTIONS_BUTTON_FONT to R.font.ubuntu_regular,
+        FacetecFontsKey.PERMISSION_TITLE_FONT to R.font.ubuntu_regular,
+        FacetecFontsKey.PERMISSION_CAPTION_FONT to R.font.ubuntu_regular,
+        FacetecFontsKey.PERMISSION_BUTTON_FONT to R.font.ubuntu_regular,
+        FacetecFontsKey.GUIDANCE_CUSTOMIZATION_HEADER_FONT to R.font.ubuntu_regular,
+        FacetecFontsKey.GUIDANCE_CUSTOMIZATION_SUBTEXT_FONT to R.font.ubuntu_regular,
+        FacetecFontsKey.GUIDANCE_CUSTOMIZATION_BUTTON_FONT to R.font.ubuntu_regular,
+        FacetecFontsKey.GUIDANCE_CUSTOMIZATION_READY_SCREEN_HEADER_FONT to R.font.ubuntu_regular,
+        FacetecFontsKey.GUIDANCE_CUSTOMIZATION_READY_SCREEN_SUBTEXT_FONT to R.font.ubuntu_regular,
+        FacetecFontsKey.GUIDANCE_CUSTOMIZATION_RETRY_SCREEN_HEADER_FONT to R.font.ubuntu_regular,
+        FacetecFontsKey.GUIDANCE_CUSTOMIZATION_RETRY_SCREEN_SUBTEXT_FONT to R.font.ubuntu_regular,
+        FacetecFontsKey.RESULT_SCREEN_CUSTOMIZATION_MESSAGE_FONT to R.font.ubuntu_regular,
+        FacetecFontsKey.FEEDBACK_CUSTOMIZATION_TEXT_FONT to R.font.ubuntu_regular
+      )
+    }
+
+    Log.d(TAG, "🏭 Iniciando construção do tema Facetec customizado...")
+    val facetecDrawables = AssetProcessor.processFacetecAssets(theme)
+    Log.d(TAG, "📦 Assets processados: ${facetecDrawables.size} encontrados")
+
+    Log.d(TAG, "🎨 Assets encontrados para processamento: ${facetecDrawables.size}")
+    facetecDrawables.forEach { (key, value) ->
+      Log.d(TAG, "   📎 $key = '$value'")
+    }
+
+    if (facetecDrawables.isNotEmpty()) {
+      Log.d(TAG, "🎨 Configurando drawables customizados: ${facetecDrawables.size} assets")
+      setFacetecDrawablesMap(facetecDrawables)
+    } else {
+      Log.d(TAG, "📋 Nenhum drawable customizado encontrado, usando padrões")
+    }
+
+    val customFacetecTexts = hashMapOf<FacetecTextKey, String>()
+
+    facetecTexts?.getString("readyHeader1")?.let { customFacetecTexts[FacetecTextKey.READY_HEADER_1] = it }
+    facetecTexts?.getString("readyHeader2")?.let { customFacetecTexts[FacetecTextKey.READY_HEADER_2] = it }
+    facetecTexts?.getString("readyMessage1")?.let { customFacetecTexts[FacetecTextKey.READY_MESSAGE_1] = it }
+    facetecTexts?.getString("readyMessage2")?.let { customFacetecTexts[FacetecTextKey.READY_MESSAGE_2] = it }
+    facetecTexts?.getString("readyButton")?.let { customFacetecTexts[FacetecTextKey.READY_BUTTON] = it }
+
+    facetecTexts?.getString("retryHeader")?.let { customFacetecTexts[FacetecTextKey.RETRY_HEADER] = it }
+    facetecTexts?.getString("retrySubheader")?.let { customFacetecTexts[FacetecTextKey.RETRY_SUBHEADER] = it }
+    facetecTexts?.getString("retryMessageSmile")?.let { customFacetecTexts[FacetecTextKey.RETRY_MESSAGE_SMILE] = it }
+    facetecTexts?.getString("retryMessageLighting")?.let { customFacetecTexts[FacetecTextKey.RETRY_MESSAGE_LIGHTING] = it }
+    facetecTexts?.getString("retryMessageContrast")?.let { customFacetecTexts[FacetecTextKey.RETRY_MESSAGE_CONTRAST] = it }
+    facetecTexts?.getString("retryYourPicture")?.let { customFacetecTexts[FacetecTextKey.RETRY_YOUR_PICTURE] = it }
+    facetecTexts?.getString("retryIdealPicture")?.let { customFacetecTexts[FacetecTextKey.RETRY_IDEAL_PICTURE] = it }
+    facetecTexts?.getString("retryButton")?.let { customFacetecTexts[FacetecTextKey.RETRY_BUTTON] = it }
+
+    facetecTexts?.getString("resultUploadMessage")?.let { customFacetecTexts[FacetecTextKey.RESULT_UPLOAD_MESSAGE] = it }
+    facetecTexts?.getString("resultSuccessMessage")?.let { customFacetecTexts[FacetecTextKey.RESULT_SUCCESS_MESSAGE] = it }
+
+    facetecTexts?.getString("feedbackLookStraightInOval")?.let { customFacetecTexts[FacetecTextKey.FEEDBACK_LOOK_STRAIGHT_IN_OVAL] = it }
+    facetecTexts?.getString("feedbackCenterFace")?.let { customFacetecTexts[FacetecTextKey.FEEDBACK_CENTER_FACE] = it }
+    facetecTexts?.getString("feedbackFaceNotFound")?.let { customFacetecTexts[FacetecTextKey.FEEDBACK_FACE_NOT_FOUND] = it }
+    facetecTexts?.getString("feedbackFaceNotLookingStraightAhead")?.let { customFacetecTexts[FacetecTextKey.FEEDBACK_FACE_NOT_LOOKING_STRAIGHT_AHEAD] = it }
+    facetecTexts?.getString("feedbackFaceNotUpright")?.let { customFacetecTexts[FacetecTextKey.FEEDBACK_FACE_NOT_UPRIGHT] = it }
+    facetecTexts?.getString("feedbackHoldSteady")?.let { customFacetecTexts[FacetecTextKey.FEEDBACK_HOLD_STEADY] = it }
+    facetecTexts?.getString("feedbackMovePhoneAway")?.let { customFacetecTexts[FacetecTextKey.FEEDBACK_MOVE_PHONE_AWAY] = it }
+    facetecTexts?.getString("feedbackMovePhoneCloser")?.let { customFacetecTexts[FacetecTextKey.FEEDBACK_MOVE_PHONE_CLOSER] = it }
+    facetecTexts?.getString("feedbackMovePhoneToEyeLevel")?.let { customFacetecTexts[FacetecTextKey.FEEDBACK_MOVE_PHONE_TO_EYE_LEVEL] = it }
+    facetecTexts?.getString("feedbackUseEvenLighting")?.let { customFacetecTexts[FacetecTextKey.FEEDBACK_USE_EVEN_LIGHTING] = it }
+    facetecTexts?.getString("feedbackFrameYourFace")?.let { customFacetecTexts[FacetecTextKey.FEEDBACK_FRAME_YOUR_FACE] = it }
+    facetecTexts?.getString("feedbackHoldSteady1")?.let { customFacetecTexts[FacetecTextKey.FEEDBACK_HOLD_STEADY_1] = it }
+    facetecTexts?.getString("feedbackHoldSteady2")?.let { customFacetecTexts[FacetecTextKey.FEEDBACK_HOLD_STEADY_2] = it }
+    facetecTexts?.getString("feedbackHoldSteady3")?.let { customFacetecTexts[FacetecTextKey.FEEDBACK_HOLD_STEADY_3] = it }
+    facetecTexts?.getString("feedbackRemoveDarkGlasses")?.let { customFacetecTexts[FacetecTextKey.FEEDBACK_REMOVE_DARK_GLASSES] = it }
+    facetecTexts?.getString("feedbackNeutralExpression")?.let { customFacetecTexts[FacetecTextKey.FEEDBACK_NEUTRAL_EXPRESSION] = it }
+    facetecTexts?.getString("feedbackConditionsTooBright")?.let { customFacetecTexts[FacetecTextKey.FEEDBACK_CONDITIONS_TOO_BRIGHT] = it }
+    facetecTexts?.getString("feedbackBrightenYourEnvironment")?.let { customFacetecTexts[FacetecTextKey.FEEDBACK_BRIGHTEN_YOUR_ENVIRONMENT] = it }
+
+    // Ready Screen
+    guidanceReadyScreenHeaderTextColor(facetecColors?.getString("readyScreenHeader") ?: "#FFFFFF")
+    guidanceReadyScreenSubtextTextColor(facetecColors?.getString("readyScreenSubtext") ?: "#BBBBBB")
+    guidanceReadyScreenTextBackgroundColor(facetecColors?.getString("readyScreenTextBackground") ?: "#BBBBBB")
+    guidanceReadyScreenOvalFillColor(facetecColors?.getString("readyScreenOvalFill") ?: "#00FF00")
+    guidanceReadyScreenTextBackgroundCornerRadius(12)
+
+    // Guidance
+    guidanceForegroundColor(facetecColors?.getString("guidanceForeground") ?: "#FFFFFF")
+    guidanceBackgroundColors(facetecColors?.getString("guidanceBackground") ?: "#1F1F1F")
+    guidanceButtonTextNormalColor(facetecColors?.getString("guidanceButtonTextNormal") ?: "#3d100c")
+    guidanceButtonTextHighlightColor(facetecColors?.getString("guidanceButtonTextHighlight") ?: "#000000")
+    guidanceButtonTextDisabledColor(facetecColors?.getString("guidanceButtonTextDisabled") ?: "#000000")
+    guidanceButtonBackgroundNormalColor(facetecColors?.getString("guidanceButtonBackgroundNormal") ?: "#00ff00")
+    guidanceButtonBackgroundHighlightColor(facetecColors?.getString("guidanceButtonBackgroundHighlight") ?: "#0F9D58")
+    guidanceButtonBackgroundDisabledColor(facetecColors?.getString("guidanceButtonBackgroundDisabled") ?: "#ff0000")
+    guidanceButtonBorderColor(facetecColors?.getString("guidanceButtonBorder") ?: "#0F9D58")
+    guidanceButtonBorderWidth(2)
+    guidanceButtonCornerRadius(12)
+
+    // Retry Screen
+    guidanceRetryScreenHeaderTextColor(facetecColors?.getString("retryScreenHeader") ?: "#FF5252")
+    guidanceRetryScreenSubtextTextColor(facetecColors?.getString("retryScreenSubtext") ?: "#DD3333")
+    guidanceRetryScreenOvalStrokeColor(facetecColors?.getString("retryScreenOvalStroke") ?: "#FFFFFF")
+    guidanceRetryScreenImageBorderColor(facetecColors?.getString("retryScreenImageBorder") ?: "#417FB2")
+    guidanceRetryScreenImageBorderWidth(3)
+    guidanceRetryScreenImageCornerRadius(12)
+
+    // Result Screen
+    resultScreenForegroundColor(facetecColors?.getString("resultScreenForeground") ?: "#0F9D58")
+    resultScreenBackgroundColors(facetecColors?.getString("resultScreenBackground") ?: "#DFFFD6")
+    resultScreenUploadProgressFillColor(facetecColors?.getString("resultScreenUploadProgressFill") ?: "#0F9D58")
+    resultScreenUploadProgressTrackColor(facetecColors?.getString("resultScreenUploadProgressTrack") ?: "#66000000")
+    resultScreenActivityIndicatorColor(facetecColors?.getString("resultScreenActivityIndicator") ?: "#0F9D58")
+    resultScreenResultAnimationBackgroundColor(facetecColors?.getString("resultScreenResultAnimationBackground") ?: "#417FB2")
+    resultScreenResultAnimationForegroundColor(facetecColors?.getString("resultScreenResultAnimationForeground") ?: "#FFFFFF")
+    resultScreenCustomActivityIndicatorAnimation(br.com.oiti.facetecsdk.R.drawable.animated_activity_indicator)
+    resultScreenCustomActivityIndicatorRotationInterval(1000)
+    resultScreenAnimationRelativeScale(1f)
+    resultScreenShowUploadProgressBar(true)
+    resultScreenCustomStaticResultAnimationUnSuccess(R.drawable.error_icon)
+    resultScreenCustomStaticResultAnimationSuccess(R.drawable.success_icon)
+    resultScreenCustomResultAnimationUnSuccess(R.drawable.error_icon)
+    resultScreenCustomResultAnimationSuccess(R.drawable.success_icon)
+    resultScreenResultAnimationUnSuccessBackgroundImage(R.drawable.error_icon)
+    resultScreenResultAnimationSuccessBackgroundImage(R.drawable.success_icon)
+    resultScreenOverrideSuccessMessage("Toque para reiniciar")
+
+    // Oval
+    ovalCustomizationStrokeWidth(4)
+    ovalCustomizationStrokeColor(facetecColors?.getString("ovalStroke") ?: "#00FF00")
+    ovalCustomizationProgressStrokeWidth(6)
+    ovalCustomizationProgressColor1(facetecColors?.getString("ovalProgressFirst") ?: "#00FF00")
+    ovalCustomizationProgressColor2(facetecColors?.getString("ovalProgressSecond") ?: "#FF0000")
+    ovalCustomizationProgressRadialOffset(8)
+
+    // Frame
+    frameBackgroundColor(facetecColors?.getString("frameBackground") ?: "#121212")
+    frameBorderColor(facetecColors?.getString("frameBorder") ?: "#FFFFFF")
+    frameBorderWidth(2)
+    frameCornerRadius(8)
+    frameElevation(5)
+
+    // Overlay
+    overlayBackgroundColor(facetecColors?.getString("overlayBackground") ?: "#80000000")
+    overlayShowBrandingImage(true)
+
+    // Feedback
+    feedbackBackgroundColors(facetecColors?.getString("feedbackBarBackground") ?: "#FFFDE7")
+    feedbackTextColor(facetecColors?.getString("feedbackMessage") ?: "#000000")
+    feedbackCornerRadius(12)
+    feedbackElevation(8)
+    feedbackEnablePulsatingText(true)
+
+    // Cancel Button
+    cancelButtonLocation(FacetecButtonLocation.TOP_RIGHT)
+    exitAnimationStyle(FacetecExitAnimationStyle.RIPPLE_IN)
+
+    setFacetecFontsMap(facetecFonts)
+    setFacetecTextMap(customFacetecTexts)
+
+    // Instructions Screen
+    setInstructionsTheme {
+      setShowInstructionScreen(showInstructionScreen)
+      setTitleText(instructionsTexts?.getString("title") ?: "Centralize seu rosto")
+      setCaptionText(instructionsTexts?.getString("caption") ?: "Mantenha-se dentro do círculo")
+      setStatusBarColor(instructionsColors?.getString("statusBar") ?: "#121212")
+      setStatusBarIsDarkIcons(false)
+      setBackgroundColor(instructionsColors?.getString("background") ?: "#121212")
+      setContinueButtonText(instructionsTexts?.getString("continueButtonText") ?: "Começar")
+      setContinueButtonColor(instructionsColors?.getString("continueButtonBackground") ?: "#0F9D58")
+    }
+
+    // Permission Screen
+    setPermissionTheme {
+      setTitle(permissionTexts?.getString("title") ?: "Permissão de Câmera")
+      setBackgroundColor(permissionColors?.getString("background") ?: "#1F1F1F")
+      setStatusBarColor(permissionColors?.getString("statusBar") ?: "#1F1F1F")
+      setStatusBarIsDarkIcons(false)
+    }
+
+    // Processing Screen
+    val processingTheme = theme?.getMap("processing")
+    val processingColors = processingTheme?.getMap("colors")
+
+    setProcessingTheme {
+      setBackgroundColor(processingColors?.getString("background") ?: "#000000")
+      setLoadingDialogColor(processingColors?.getString("loading") ?: "#FFFFFF")
+      setStatusBarColor(processingColors?.getString("statusBar") ?: "#000000")
+      setStatusBarIsDarkIcons(false)
+      setLoadingIndicatorSize(80)
+    }
+  }
+
+  fun create(isCustom: Boolean, theme: ReadableMap? = null, context: Context? = null): FacetecTheme =
+    if (isCustom) buildCustom(theme, context) else buildDefault()
+}