JAAK FaceDetector SDK Android

dependencyResolutionManagement {
    repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
    repositories {
        google()
        mavenCentral()
        maven { url 'https://jitpack.io' }
        maven {
            url 'https://us-maven.pkg.dev/jaak-saas/jaak-public-android-repo-release'
        }
    }
}

dependencies {
    // JAAK Face Detector SDK
    implementation 'ai.jaak.android:facedetector:3.0.0'
    
    // Dependencias requeridas
    implementation 'com.google.dagger:hilt-android:2.46'
    kapt 'com.google.dagger:hilt-compiler:2.46'
}

buildscript {
    ext.kotlin_version = "1.9.22"
    ext.hilt_version = '2.46'
    dependencies {
        classpath 'com.android.tools.build:gradle:8.3.2'
        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
        classpath "com.google.dagger:hilt-android-gradle-plugin:$hilt_version"
    }
}

plugins {
    id 'com.android.application'
    id 'org.jetbrains.kotlin.android'
    id 'kotlin-kapt'
    id 'dagger.hilt.android.plugin'
}

GOOGLE_INTEGRITY_PROJECT_NUMBER=123456789012

import ai.jaak.facedetector.FaceDetectorSDK
import android.app.Application
import dagger.hilt.android.HiltAndroidApp

@HiltAndroidApp
class MyApplication : Application() {
    
    override fun onCreate() {
        super.onCreate()
        
        // Inicializar el SDK con su licencia
        FaceDetectorSDK.initialize(
            context = this,
            license = "SU-LICENCIA-AQUI"
        )
    }
}

<application
    android:name=".MyApplication"
    android:allowBackup="true"
    ...>

import ai.jaak.facedetector.FaceDetectorSDK
import ai.jaak.facedetector.interfaces.FaceDetectorListener
import android.net.Uri
import android.os.Bundle
import androidx.appcompat.app.AppCompatActivity
import dagger.hilt.android.AndroidEntryPoint

@AndroidEntryPoint
class MainActivity : AppCompatActivity(), FaceDetectorListener {
    
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        
        // Configurar el SDK
        setupSDK()
        
        // Iniciar verificación
        startVerification()
    }
    
    private fun setupSDK() {
        FaceDetectorSDK.apply {
            // Configurar ambiente
            setEnvironment(FaceDetectorSDK.Environment.PRODUCTION)
            
            // Configurar modo de servicio
            setEnableService(true) // true = verificación completa
            
            // Configurar captura automática
            setAutoCapture(true) // true = captura automática cuando detecta rostro
            
            // Configurar límites de video (opcional)
            setVideoDuration(10) // 10 segundos máximo
            setVideoSize(5) // 5 MB máximo
        }
    }
    
    private fun startVerification() {
        // Iniciar el proceso de verificación
        FaceDetectorSDK.startVerification(
            activity = this,
            listener = this,
            selfieReferenceUri = null // o Uri de foto de documento
        )
    }
    
    // Callbacks del SDK
    override fun onSuccessFaceDetector(response: String) {
        // ✅ Verificación exitosa
        // response contiene JSON con resultados completos
        Log.d("FaceDetector", "Success: $response")
        processSuccessResponse(response)
    }
    
    override fun onImageCaptured(imageUri: Uri) {
        // 📷 Imagen capturada (solo si enableService = false)
        Log.d("FaceDetector", "Image captured: $imageUri")
    }
    
    override fun onErrorFaceDetector(errorType: String, errorMessage: String) {
        // ❌ Error en la verificación
        Log.e("FaceDetector", "Error: $errorType - $errorMessage")
        handleError(errorType, errorMessage)
    }
    
    override fun onCancelFaceDetector() {
        // 🚫 Usuario canceló el proceso
        Log.d("FaceDetector", "User cancelled verification")
    }
}

FaceDetectorSDK.setEnvironment(FaceDetectorSDK.Environment.SANDBOX)

// Modo servicio completo
FaceDetectorSDK.setEnableService(true)

// Modo solo captura
FaceDetectorSDK.setEnableService(false)

FaceDetectorSDK.setAutoCapture(true) // Recomendado para mejor UX

FaceDetectorSDK.setVideoDuration(15) // 15 segundos máximo

FaceDetectorSDK.setVideoSize(8) // Máximo 8 MB

// Desde archivo local
val imageFile = File(context.filesDir, "documento.jpg")
val uri = FileProvider.getUriForFile(
    context,
    "${context.packageName}.provider",
    imageFile
)

// Desde galería (después de que usuario seleccione)
override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
    if (resultCode == RESULT_OK && data != null) {
        val imageUri = data.data // Este es el URI que puede usar
    }
}

// Desde captura de cámara
val photoUri: Uri = // URI de foto previamente capturada

// Sin comparación facial (solo liveness)
FaceDetectorSDK.startVerification(
    activity = this,
    listener = this,
    selfieReferenceUri = null
)

// Con comparación facial
val documentPhotoUri = getDocumentPhotoUri() // Su método para obtener URI
FaceDetectorSDK.startVerification(
    activity = this,
    listener = this,
    selfieReferenceUri = documentPhotoUri
)

interface FaceDetectorListener {
    fun onSuccessFaceDetector(response: String)
    fun onImageCaptured(imageUri: Uri)
    fun onErrorFaceDetector(errorType: String, errorMessage: String)
    fun onCancelFaceDetector()
}

{
  "session_id": "550e8400-e29b-41d4-a716-446655440000",
  "liveness": {
    "status": "success",
    "confidence_score": 0.97,
    "is_live": true,
    "attempts": 1,
    "indicators": {
      "motion_detected": true,
      "depth_analysis": true,
      "texture_analysis": true,
      "reflection_check": true
    }
  },
  "face": {
    "status": "success",
    "comparison_score": 0.95,
    "is_match": true,
    "confidence_level": "high",
    "face_quality": {
      "sharpness": 0.92,
      "brightness": 0.88,
      "face_size": 0.94
    }
  },
  "oto": {
    "status": "success",
    "fraud_detected": false,
    "fraud_indicators": [],
    "device_integrity": true,
    "risk_score": 0.05
  },
  "summary": {
    "overall_status": "approved",
    "verification_passed": true,
    "risk_level": "low",
    "recommendation": "approve",
    "timestamp": "2025-11-13T10:30:45Z"
  }
}

override fun onSuccessFaceDetector(response: String) {
    try {
        val jsonResponse = JSONObject(response)
        
        // Obtener resumen general
        val summary = jsonResponse.getJSONObject("summary")
        val overallStatus = summary.getString("overall_status")
        val verificationPassed = summary.getBoolean("verification_passed")
        val riskLevel = summary.getString("risk_level")
        
        // Obtener scores específicos
        val liveness = jsonResponse.getJSONObject("liveness")
        val livenessScore = liveness.getDouble("confidence_score")
        val isLive = liveness.getBoolean("is_live")
        
        // Obtener face matching (si se realizó)
        val face = jsonResponse.getJSONObject("face")
        val faceStatus = face.getString("status")
        if (faceStatus == "success") {
            val comparisonScore = face.getDouble("comparison_score")
            val isMatch = face.getBoolean("is_match")
            Log.d("FaceDetector", "Face match score: $comparisonScore")
        }
        
        // Obtener análisis de fraude
        val oto = jsonResponse.getJSONObject("oto")
        val fraudDetected = oto.getBoolean("fraud_detected")
        val riskScore = oto.getDouble("risk_score")
        
        // Tomar decisión
        when (overallStatus) {
            "approved" -> {
                if (verificationPassed && !fraudDetected) {
                    // ✅ Usuario verificado exitosamente
                    approveUser()
                    showSuccess("Verificación exitosa")
                }
            }
            "rejected" -> {
                // ❌ Verificación fallida
                rejectUser()
                showError("Verificación fallida: posible fraude")
            }
            "review" -> {
                // ⚠️ Requiere revisión manual
                sendToManualReview()
                showWarning("Verificación requiere revisión manual")
            }
        }
        
        // Guardar session_id para auditoría
        val sessionId = jsonResponse.getString("session_id")
        saveToDatabase(sessionId, response)
        
    } catch (e: JSONException) {
        Log.e("FaceDetector", "Error parsing response", e)
    }
}

override fun onImageCaptured(imageUri: Uri) {
    // Opción 1: Convertir a Base64 para enviar a su servidor
    val base64Image = convertImageToBase64(imageUri)
    sendToYourServer(base64Image)
    
    // Opción 2: Subir directamente como multipart
    uploadImageToServer(imageUri)
    
    // Opción 3: Guardar en galería
    saveToGallery(imageUri)
    
    // Opción 4: Mostrar en ImageView
    binding.imageView.setImageURI(imageUri)
}

private fun convertImageToBase64(uri: Uri): String {
    val inputStream = contentResolver.openInputStream(uri)
    val bytes = inputStream?.readBytes()
    inputStream?.close()
    return Base64.encodeToString(bytes, Base64.NO_WRAP)
}

override fun onErrorFaceDetector(errorType: String, errorMessage: String) {
    Log.e("FaceDetector", "Error: $errorType - $errorMessage")
    
    when (errorType) {
        "license_invalid", "license_expired" -> {
            // Error crítico: contactar a JAAK
            showCriticalError(
                "Error de licencia",
                "Por favor contacte a [email protected]"
            )
        }
        
        "camera_permission_denied" -> {
            // Solicitar permiso nuevamente
            requestCameraPermission()
            showError(
                "Permiso requerido",
                "Necesitamos acceso a la cámara para verificar tu identidad"
            )
        }
        
        "location_permission_denied" -> {
            // Solicitar permiso de ubicación (requerido por ML Kit)
            requestLocationPermission()
            showError(
                "Permiso requerido",
                "Necesitamos acceso a la ubicación para la detección facial"
            )
        }
        
        "network_error" -> {
            // Problema de conectividad
            showRetryableError(
                "Sin conexión",
                "Verifica tu conexión a internet e intenta nuevamente"
            )
        }
        
        "face_not_detected" -> {
            // Usuario no posicionó bien su rostro
            showRetryableError(
                "Rostro no detectado",
                "Asegúrate de estar bien iluminado y mirando a la cámara"
            )
        }
        
        "liveness_failed" -> {
            // Falló la prueba de vida
            showRetryableError(
                "Verificación fallida",
                "No pudimos verificar que eres una persona real. Por favor, intenta nuevamente"
            )
        }
        
        "face_comparison_failed" -> {
            // Los rostros no coinciden
            showError(
                "Rostros no coinciden",
                "El rostro capturado no coincide con el documento proporcionado"
            )
        }
        
        "fraud_detected" -> {
            // Intento de fraude detectado
            showCriticalError(
                "Verificación rechazada",
                "No fue posible completar la verificación"
            )
            // Registrar para auditoría
            logSecurityEvent("fraud_attempt", errorMessage)
        }
        
        "max_attempts_exceeded" -> {
            // Agotó los 3 intentos
            showError(
                "Máximo de intentos",
                "Has superado el número máximo de intentos. Por favor, intenta más tarde"
            )
            // Bloquear temporalmente
            blockUserTemporarily()
        }
        
        "server_error" -> {
            // Error del servidor
            showRetryableError(
                "Error temporal",
                "Ocurrió un problema temporal. Por favor, intenta en unos minutos"
            )
        }
        
        "invalid_reference_image" -> {
            // Imagen de documento inválida
            showError(
                "Imagen no válida",
                "La foto del documento no es válida. Por favor, sube una nueva foto"
            )
            // Permitir subir nueva foto
            requestNewDocumentPhoto()
        }
        
        else -> {
            // Error genérico
            showError(
                "Error inesperado",
                "Ocurrió un error. Por favor, intenta nuevamente"
            )
        }
    }
}

// Métodos auxiliares
private fun showError(title: String, message: String) {
    AlertDialog.Builder(this)
        .setTitle(title)
        .setMessage(message)
        .setPositiveButton("OK") { dialog, _ -> dialog.dismiss() }
        .show()
}

private fun showRetryableError(title: String, message: String) {
    AlertDialog.Builder(this)
        .setTitle(title)
        .setMessage(message)
        .setPositiveButton("Reintentar") { dialog, _ ->
            dialog.dismiss()
            startVerification()
        }
        .setNegativeButton("Cancelar") { dialog, _ -> dialog.dismiss() }
        .show()
}

private fun showCriticalError(title: String, message: String) {
    AlertDialog.Builder(this)
        .setTitle(title)
        .setMessage(message)
        .setPositiveButton("Entendido") { dialog, _ ->
            dialog.dismiss()
            finish() // Cerrar activity
        }
        .setCancelable(false)
        .show()
}

override fun onCancelFaceDetector() {
    Log.d("FaceDetector", "Usuario canceló la verificación")
    
    // Opción 1: Regresar a pantalla anterior
    finish()
    
    // Opción 2: Mostrar mensaje y permitir reintentar
    showCancelMessage()
    
    // Opción 3: Registrar evento de cancelación
    logAnalyticsEvent("verification_cancelled")
}

private fun showCancelMessage() {
    AlertDialog.Builder(this)
        .setTitle("Verificación cancelada")
        .setMessage("¿Deseas intentar nuevamente?")
        .setPositiveButton("Sí") { dialog, _ ->
            dialog.dismiss()
            startVerification()
        }
        .setNegativeButton("No") { dialog, _ ->
            dialog.dismiss()
            finish()
        }
        .show()
}

@AndroidEntryPoint
class VerificationActivity : AppCompatActivity(), FaceDetectorListener {
    
    private lateinit var binding: ActivityVerificationBinding
    
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        binding = ActivityVerificationBinding.inflate(layoutInflater)
        setContentView(binding.root)
        
        setupUI()
        configureSDK()
    }
    
    private fun setupUI() {
        binding.btnStartVerification.setOnClickListener {
            startVerificationProcess()
        }
    }
    
    private fun configureSDK() {
        FaceDetectorSDK.apply {
            setEnvironment(FaceDetectorSDK.Environment.PRODUCTION)
            setEnableService(true) // Usar servicio completo de JAAK
            setAutoCapture(true)
            setVideoDuration(10)
            setVideoSize(5)
        }
    }
    
    private fun startVerificationProcess() {
        // Mostrar loading
        binding.progressBar.visibility = View.VISIBLE
        binding.btnStartVerification.isEnabled = false
        
        // Obtener foto del documento (si ya la tienes)
        val documentPhotoUri = getDocumentPhotoUri()
        
        // Iniciar verificación
        FaceDetectorSDK.startVerification(
            activity = this,
            listener = this,
            selfieReferenceUri = documentPhotoUri
        )
    }
    
    override fun onSuccessFaceDetector(response: String) {
        binding.progressBar.visibility = View.GONE
        
        try {
            val json = JSONObject(response)
            val summary = json.getJSONObject("summary")
            
            val overallStatus = summary.getString("overall_status")
            val verificationPassed = summary.getBoolean("verification_passed")
            
            if (overallStatus == "approved" && verificationPassed) {
                // ✅ Verificación exitosa
                showSuccessScreen(response)
                saveVerificationResult(response)
            } else {
                // ❌ Verificación fallida
                showFailureScreen(summary.getString("recommendation"))
            }
        } catch (e: JSONException) {
            Log.e(TAG, "Error parsing response", e)
            showError("Error procesando respuesta")
        }
    }
    
    override fun onImageCaptured(imageUri: Uri) {
        // No se usa en modo servicio completo
    }
    
    override fun onErrorFaceDetector(errorType: String, errorMessage: String) {
        binding.progressBar.visibility = View.GONE
        binding.btnStartVerification.isEnabled = true
        
        handleError(errorType, errorMessage)
    }
    
    override fun onCancelFaceDetector() {
        binding.progressBar.visibility = View.GONE
        binding.btnStartVerification.isEnabled = true
        
        Toast.makeText(this, "Verificación cancelada", Toast.LENGTH_SHORT).show()
    }
    
    private fun showSuccessScreen(response: String) {
        val intent = Intent(this, SuccessActivity::class.java)
        intent.putExtra("verification_data", response)
        startActivity(intent)
        finish()
    }
    
    private fun showFailureScreen(recommendation: String) {
        AlertDialog.Builder(this)
            .setTitle("Verificación fallida")
            .setMessage("No se pudo completar la verificación: $recommendation")
            .setPositiveButton("Reintentar") { dialog, _ ->
                dialog.dismiss()
                startVerificationProcess()
            }
            .setNegativeButton("Cancelar") { dialog, _ ->
                dialog.dismiss()
                finish()
            }
            .show()
    }
}

@AndroidEntryPoint
class CaptureActivity : AppCompatActivity(), FaceDetectorListener {
    
    private lateinit var binding: ActivityCaptureBinding
    
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        binding = ActivityCaptureBinding.inflate(layoutInflater)
        setContentView(binding.root)
        
        configureSDK()
        
        binding.btnCapture.setOnClickListener {
            startCapture()
        }
    }
    
    private fun configureSDK() {
        FaceDetectorSDK.apply {
            setEnvironment(FaceDetectorSDK.Environment.PRODUCTION)
            setEnableService(false) // Solo captura, sin servicio JAAK
            setAutoCapture(true)
        }
    }
    
    private fun startCapture() {
        binding.progressBar.visibility = View.VISIBLE
        
        FaceDetectorSDK.startVerification(
            activity = this,
            listener = this,
            selfieReferenceUri = null
        )
    }
    
    override fun onImageCaptured(imageUri: Uri) {
        binding.progressBar.visibility = View.GONE
        
        // Mostrar imagen capturada
        binding.imagePreview.setImageURI(imageUri)
        binding.imagePreview.visibility = View.VISIBLE
        
        // Procesar imagen en su propio servidor
        lifecycleScope.launch(Dispatchers.IO) {
            try {
                // Convertir a Base64
                val base64Image = convertToBase64(imageUri)
                
                // Enviar a su servidor
                val response = sendToMyServer(base64Image)
                
                withContext(Dispatchers.Main) {
                    handleServerResponse(response)
                }
            } catch (e: Exception) {
                withContext(Dispatchers.Main) {
                    showError("Error procesando imagen: ${e.message}")
                }
            }
        }
    }
    
    override fun onSuccessFaceDetector(response: String) {
        // No se usa cuando enableService = false
    }
    
    override fun onErrorFaceDetector(errorType: String, errorMessage: String) {
        binding.progressBar.visibility = View.GONE
        showError("$errorType: $errorMessage")
    }
    
    override fun onCancelFaceDetector() {
        binding.progressBar.visibility = View.GONE
        finish()
    }
    
    private suspend fun convertToBase64(uri: Uri): String {
        return withContext(Dispatchers.IO) {
            val inputStream = contentResolver.openInputStream(uri)
            val bytes = inputStream?.readBytes()
            inputStream?.close()
            Base64.encodeToString(bytes, Base64.NO_WRAP)
        }
    }
    
    private suspend fun sendToMyServer(base64Image: String): String {
        // Implementar llamada a su API
        val url = "https://your-api.com/verify-face"
        // ... código de API call
        return "response_from_server"
    }
    
    private fun handleServerResponse(response: String) {
        // Procesar respuesta de su servidor
        Toast.makeText(this, "Imagen procesada exitosamente", Toast.LENGTH_SHORT).show()
    }
}

// ViewModel
@HiltViewModel
class VerificationViewModel @Inject constructor(
    private val repository: VerificationRepository
) : ViewModel() {
    
    private val _verificationState = MutableLiveData<VerificationState>()
    val verificationState: LiveData<VerificationState> = _verificationState
    
    fun processVerificationResult(response: String) {
        viewModelScope.launch {
            try {
                _verificationState.value = VerificationState.Loading
                
                val json = JSONObject(response)
                val summary = json.getJSONObject("summary")
                
                if (summary.getBoolean("verification_passed")) {
                    // Guardar en base de datos o servidor
                    repository.saveVerification(response)
                    _verificationState.value = VerificationState.Success(response)
                } else {
                    _verificationState.value = VerificationState.Failed(
                        summary.getString("recommendation")
                    )
                }
            } catch (e: Exception) {
                _verificationState.value = VerificationState.Error(e.message ?: "Error")
            }
        }
    }
}

// States
sealed class VerificationState {
    object Loading : VerificationState()
    data class Success(val data: String) : VerificationState()
    data class Failed(val reason: String) : VerificationState()
    data class Error(val message: String) : VerificationState()
}

// Activity
@AndroidEntryPoint
class VerificationActivity : AppCompatActivity(), FaceDetectorListener {
    
    private val viewModel: VerificationViewModel by viewModels()
    private lateinit var binding: ActivityVerificationBinding
    
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        binding = ActivityVerificationBinding.inflate(layoutInflater)
        setContentView(binding.root)
        
        observeVerificationState()
        configureSDK()
        
        binding.btnStart.setOnClickListener {
            startVerification()
        }
    }
    
    private fun observeVerificationState() {
        viewModel.verificationState.observe(this) { state ->
            when (state) {
                is VerificationState.Loading -> showLoading()
                is VerificationState.Success -> showSuccess(state.data)
                is VerificationState.Failed -> showFailure(state.reason)
                is VerificationState.Error -> showError(state.message)
            }
        }
    }
    
    private fun configureSDK() {
        FaceDetectorSDK.apply {
            setEnvironment(FaceDetectorSDK.Environment.PRODUCTION)
            setEnableService(true)
            setAutoCapture(true)
            setVideoDuration(10)
            setVideoSize(5)
        }
    }
    
    private fun startVerification() {
        FaceDetectorSDK.startVerification(
            activity = this,
            listener = this,
            selfieReferenceUri = null
        )
    }
    
    override fun onSuccessFaceDetector(response: String) {
        viewModel.processVerificationResult(response)
    }
    
    override fun onImageCaptured(imageUri: Uri) {
        // No usado en este ejemplo
    }
    
    override fun onErrorFaceDetector(errorType: String, errorMessage: String) {
        binding.progressBar.visibility = View.GONE
        showError("$errorType: $errorMessage")
    }
    
    override fun onCancelFaceDetector() {
        binding.progressBar.visibility = View.GONE
        finish()
    }
    
    private fun showLoading() {
        binding.progressBar.visibility = View.VISIBLE
    }
    
    private fun showSuccess(data: String) {
        binding.progressBar.visibility = View.GONE
        // Navegar a pantalla de éxito
    }
    
    private fun showFailure(reason: String) {
        binding.progressBar.visibility = View.GONE
        // Mostrar mensaje de fallo
    }
    
    private fun showError(message: String) {
        Toast.makeText(this, message, Toast.LENGTH_LONG).show()
    }
}

private val retryableErrors = setOf(
    "network_error",
    "face_not_detected",
    "liveness_failed",
    "camera_not_available"
)

override fun onErrorFaceDetector(errorType: String, errorMessage: String) {
    if (errorType in retryableErrors && attemptCount < MAX_ATTEMPTS) {
        showRetryDialog(errorMessage)
    } else {
        showFinalError(errorType, errorMessage)
    }
}

private fun showRetryDialog(message: String) {
    AlertDialog.Builder(this)
        .setTitle("Error temporal")
        .setMessage(message)
        .setPositiveButton("Reintentar") { _, _ ->
            attemptCount++
            startVerification()
        }
        .setNegativeButton("Cancelar") { _, _ -> finish() }
        .show()
}

private val criticalErrors = setOf(
    "license_invalid",
    "license_expired",
    "fraud_detected",
    "max_attempts_exceeded"
)

override fun onErrorFaceDetector(errorType: String, errorMessage: String) {
    if (errorType in criticalErrors) {
        handleCriticalError(errorType, errorMessage)
        // Registrar para auditoría
        logSecurityEvent(errorType, errorMessage)
    }
}

private fun handleCriticalError(type: String, message: String) {
    AlertDialog.Builder(this)
        .setTitle("Error crítico")
        .setMessage(getFriendlyMessage(type))
        .setPositiveButton("Entendido") { _, _ ->
            finish()
        }
        .setCancelable(false)
        .show()
}

private fun getFriendlyMessage(errorType: String): String {
    return when (errorType) {
        "license_invalid" -> "Error de configuración. Por favor contacte a soporte."
        "license_expired" -> "Su licencia ha expirado. Contacte a [email protected]"
        "fraud_detected" -> "No fue posible completar la verificación."
        "max_attempts_exceeded" -> "Ha excedido el número máximo de intentos."
        else -> "Ocurrió un error. Por favor intente más tarde."
    }
}

override fun onErrorFaceDetector(errorType: String, errorMessage: String) {
    when (errorType) {
        "camera_permission_denied" -> {
            if (shouldShowRequestPermissionRationale(Manifest.permission.CAMERA)) {
                showPermissionRationale()
            } else {
                showPermissionSettings()
            }
        }
        "location_permission_denied" -> {
            if (shouldShowRequestPermissionRationale(Manifest.permission.ACCESS_FINE_LOCATION)) {
                showLocationPermissionRationale()
            } else {
                showPermissionSettings()
            }
        }
    }
}

private fun showPermissionRationale() {
    AlertDialog.Builder(this)
        .setTitle("Permiso necesario")
        .setMessage("Necesitamos acceso a la cámara para verificar tu identidad.")
        .setPositiveButton("Permitir") { _, _ ->
            requestCameraPermission()
        }
        .setNegativeButton("Cancelar") { _, _ -> finish() }
        .show()
}

private fun showPermissionSettings() {
    AlertDialog.Builder(this)
        .setTitle("Permiso denegado")
        .setMessage("Por favor habilita el permiso de cámara en Configuración.")
        .setPositiveButton("Ir a Configuración") { _, _ ->
            openAppSettings()
        }
        .setNegativeButton("Cancelar") { _, _ -> finish() }
        .show()
}

private fun openAppSettings() {
    val intent = Intent(Settings.ACTION_APPLICATION_DETAILS_SETTINGS)
    val uri = Uri.fromParts("package", packageName, null)
    intent.data = uri
    startActivity(intent)
}

// ✅ BUENO: Cifrar datos sensibles
fun saveVerificationResult(response: String) {
    val encrypted = encryptData(response)
    securePreferences.save("verification", encrypted)
}

// ✅ BUENO: Validar resultados en servidor
fun validateVerification(sessionId: String) {
    apiService.validateSession(sessionId) { isValid ->
        if (isValid) approveUser()
    }
}

// ❌ MALO: Guardar sin cifrar
sharedPreferences.edit()
    .putString("verification", response)
    .apply()

// ✅ BUENO: Mostrar progreso
override fun onSuccessFaceDetector(response: String) {
    showProgressDialog("Procesando resultados...")
    processResponse(response)
}

// ✅ BUENO: Dar feedback inmediato
FaceDetectorSDK.startVerification(...)
showLoading("Iniciando cámara...")

// ✅ BUENO: Mensajes claros
showError("Rostro no detectado", 
    "Por favor asegúrate de estar bien iluminado")

// ❌ MALO: Sin feedback
FaceDetectorSDK.startVerification(...)
// Usuario no sabe qué está pasando

// ✅ BUENO: Procesar en background
override fun onSuccessFaceDetector(response: String) {
    lifecycleScope.launch(Dispatchers.IO) {
        val processed = processLargeResponse(response)
        withContext(Dispatchers.Main) {
            updateUI(processed)
        }
    }
}

// ✅ BUENO: Configurar límites apropiados
FaceDetectorSDK.apply {
    setVideoDuration(8) // Suficiente para liveness
    setVideoSize(5) // Balance entre calidad y tamaño
}

// ❌ MALO: Procesar en main thread
override fun onSuccessFaceDetector(response: String) {
    val processed = heavyProcessing(response) // Bloquea UI
    updateUI(processed)
}

// ✅ BUENO: Limpiar recursos
override fun onDestroy() {
    super.onDestroy()
    // El SDK maneja su propio cleanup automáticamente
    // Solo limpie sus propios recursos
    disposables.clear()
}

// ✅ BUENO: Manejar rotación
override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    // El SDK maneja rotación automáticamente
    // Solo restaure su propio estado si es necesario
    savedInstanceState?.let {
        attemptCount = it.getInt("attempt_count", 0)
    }
}

// ✅ BUENO: Log detallado en desarrollo
if (BuildConfig.DEBUG) {
    Log.d(TAG, "Starting verification with environment: ${getCurrentEnvironment()}")
    Log.d(TAG, "Configuration: enableService=$enableService, autoCapture=$autoCapture")
}

// ✅ BUENO: Registrar eventos importantes
override fun onSuccessFaceDetector(response: String) {
    analytics.logEvent("verification_success", Bundle().apply {
        putString("session_id", getSessionId(response))
        putLong("duration", verificationDuration)
    })
}

// ✅ BUENO: Monitorear errores
override fun onErrorFaceDetector(errorType: String, errorMessage: String) {
    crashlytics.recordException(
        Exception("Verification failed: $errorType")
    )
}

// ✅ BUENO: Usar ambiente SANDBOX para pruebas
@Before
fun setup() {
    FaceDetectorSDK.setEnvironment(FaceDetectorSDK.Environment.SANDBOX)
}

// ✅ BUENO: Probar casos de error
@Test
fun testVerificationFailure() {
    // Simular error y verificar manejo
}

// ✅ BUENO: Probar en dispositivos reales
// No confiar solo en emulador para detección facial