react-native-vision-camera-spoof-detector 1.0.1 → 1.0.3

package/android/src/main/java/com/faceantispoof/FaceAntiSpoofingAdvanced.kt

@@ -8,17 +8,19 @@ import java.io.IOException
 import java.nio.MappedByteBuffer
 import java.nio.channels.FileChannel
 import java.io.FileInputStream
-import kotlin.math.abs
+import kotlin.math.*
 import java.nio.ByteBuffer
 import java.nio.ByteOrder
-import java.util.HashMap
+import java.util.*
 import android.util.Log
+import kotlin.collections.ArrayList
+import android.util.Base64
 
 class FaceAntiSpoofingAdvanced(private val assetManager: AssetManager) {
 
     companion object {
         const val INPUT_IMAGE_SIZE = 256
-        const val THRESHOLD = 0.2f
+        const val BASE_THRESHOLD = 0.2f 
         const val ROUTE_INDEX = 6
         const val LAPLACE_THRESHOLD = 50
         const val LAPLACIAN_THRESHOLD = 1000
@@ -29,6 +31,16 @@ class FaceAntiSpoofingAdvanced(private val assetManager: AssetManager) {
         const val ACCELERATOR_CPU = "CPU"
         const val ACCELERATOR_GPU = "GPU"
         const val ACCELERATOR_NNAPI = "NNAPI"
+        
+        // Advanced spoof detection constants
+        private const val HISTORY_SIZE = 10
+        private const val TEMPORAL_CONSISTENCY_THRESHOLD = 0.08f
+        private const val SCORE_VARIANCE_THRESHOLD = 0.02f
+        private const val MIN_FRAMES_FOR_ANALYSIS = 5
+        private const val DYNAMIC_THRESHOLD_MULTIPLIER = 1.3f
+        private const val TEXTURE_COMPLEXITY_THRESHOLD = 800
+        private const val COLOR_SATURATION_THRESHOLD = 0.4f
+        private const val DEPTH_VARIATION_THRESHOLD = 0.1f
     }
 
     private var interpreter: Interpreter? = null
@@ -48,6 +60,21 @@ class FaceAntiSpoofingAdvanced(private val assetManager: AssetManager) {
     private var grayscaleBuffer: IntArray? = null
     private val yuvConverter = YuvToFloatArrayConverter()
 
+    // Advanced spoof detection fields
+    private val scoreHistory = LinkedList<Float>()
+    private val laplacianHistory = LinkedList<Int>()
+    private var frameCount = 0
+    private var adaptiveThreshold = BASE_THRESHOLD
+    private var environmentAssessment = EnvironmentAssessment()
+
+    data class EnvironmentAssessment(
+        var avgBrightness: Float = 0f,
+        var brightnessVariance: Float = 0f,
+        var estimatedDistance: Float = 0f,
+        var lightingConsistency: Float = 0f,
+        var lastAssessmentTime: Long = 0
+    )
+
     init {
         initializeInterpreter()
     }
@@ -58,13 +85,11 @@ class FaceAntiSpoofingAdvanced(private val assetManager: AssetManager) {
             val options = Interpreter.Options()
             options.setNumThreads(4)
             
-            // Try to add GPU delegate first
             if (tryAddGpuDelegate(options)) {
                 currentAccelerator = ACCELERATOR_GPU
                 Log.i(TAG, "GPU delegate enabled successfully")
             } 
             else {
-                // GPU not available, enable NNAPI through interpreter options
                 try {
                     options.setUseNNAPI(true)
                     currentAccelerator = ACCELERATOR_NNAPI
@@ -77,12 +102,10 @@ class FaceAntiSpoofingAdvanced(private val assetManager: AssetManager) {
             
             interpreter = Interpreter(modelBuffer, options)
             
-            // Try to find output indices once and prepare outputs map
             try {
                 outputIndex0 = interpreter!!.getOutputIndex("Identity")
                 outputIndex1 = interpreter!!.getOutputIndex("Identity_1")
             } catch (e: Exception) {
-                // Keep defaults (0 and 1) if named outputs not available
                 Log.w(TAG, "Could not resolve named output indices, using defaults: ${e.message}")
             }
             
@@ -97,13 +120,8 @@ class FaceAntiSpoofingAdvanced(private val assetManager: AssetManager) {
         }
     }
 
-    /**
-     * Try to enable GPU delegate for modern devices
-     * Returns true if GPU delegate was successfully added
-     */
     private fun tryAddGpuDelegate(options: Interpreter.Options): Boolean {
         return try {
-            // Check if device supports GPU delegate
             val compatibilityList = CompatibilityList()
             if (compatibilityList.isDelegateSupportedOnThisDevice) {
                 gpuDelegate = GpuDelegate(compatibilityList.bestOptionsForThisDevice)
@@ -122,9 +140,6 @@ class FaceAntiSpoofingAdvanced(private val assetManager: AssetManager) {
         }
     }
 
-    /**
-     * Get the currently active accelerator type
-     */
     fun getAccelerator(): String = currentAccelerator
 
     fun advancedAntiSpoofing(nv21: ByteArray, width: Int, height: Int): AntiSpoofingResult {
@@ -132,58 +147,107 @@ class FaceAntiSpoofingAdvanced(private val assetManager: AssetManager) {
             return AntiSpoofingResult(
                 neuralNetworkScore = 0f,
                 laplacianScore = 0,
+                textureComplexity = 0,
+                temporalConsistency = 0f,
+                colorSaturation = 0f,
                 combinedScore = 0f,
                 isLive = false,
-                label = "Not Initialized"
+                confidence = 0f,
+                label = "Not Initialized",
+                spoofType = "UNKNOWN"
             )
         }
 
-        // Validate input parameters
-        if (nv21 == null || nv21.isEmpty()) {
-            Log.e(TAG, "Invalid NV21 buffer: null or empty")
-            return AntiSpoofingResult(0f, 0, 0f, false, "Error: Invalid NV21 buffer")
-        }
-
-        if (width <= 0 || height <= 0) {
-            Log.e(TAG, "Invalid frame dimensions: width=$width, height=$height")
-            return AntiSpoofingResult(0f, 0, 0f, false, "Error: Invalid dimensions")
+        // Enhanced input validation
+        if (nv21.isEmpty()) {
+            return AntiSpoofingResult(0f, 0, 0, 0f, 0f, 0f, false, 0f, "Error: Invalid NV21 buffer", "INVALID_INPUT")
         }
 
         val expectedSize = width * height + (width * height) / 2
         if (nv21.size < expectedSize) {
-            Log.e(TAG, "NV21 buffer too small: expected >= $expectedSize, got ${nv21.size}")
-            return AntiSpoofingResult(0f, 0, 0f, false, "Error: Buffer size mismatch")
+            return AntiSpoofingResult(0f, 0, 0, 0f, 0f, 0f, false, 0f, "Error: Buffer size mismatch", "INVALID_INPUT")
         }
 
         return try {
+            // Multiple detection techniques
             val nnScore = neuralNetworkAntiSpoofing(nv21, width, height)
             val laplacianScore = laplacian(nv21, width, height)
+            val textureScore = calculateTextureComplexity(nv21, width, height)
+            val colorSat = calculateColorSaturation(nv21, width, height)
+            val temporalConsistency = calculateTemporalConsistency(nnScore)
+            
+            // Update adaptive threshold based on environment
+            updateAdaptiveThreshold(nv21, width, height)
+            
+            // Multi-factor spoof detection
+            val spoofDetection = detectSpoofType(
+                nnScore, 
+                laplacianScore, 
+                textureScore, 
+                colorSat, 
+                temporalConsistency
+            )
+            
+            val confidence = calculateConfidence(nnScore, laplacianScore, textureScore, temporalConsistency)
+            val combinedScore = calculateCombinedScore(nnScore, laplacianScore, textureScore, temporalConsistency)
+            
+            // Final decision with multiple safeguards
+            val isLive = isLiveFace(
+                nnScore, 
+                laplacianScore, 
+                textureScore, 
+                colorSat, 
+                temporalConsistency, 
+                spoofDetection
+            )
 
-            val isLive = nnScore < THRESHOLD && laplacianScore > LAPLACIAN_THRESHOLD
-            val combinedScore = calculateCombinedScore(nnScore, laplacianScore)
+            // Generate 640×640 JPEG Base64 for Recognition API when face is live
+            var recognitionImageBase64: String? = null
+            val DEBUG_FORCE_BASE64 = false // Set to true to force Base64 generation for testing
+            
+            if (isLive || DEBUG_FORCE_BASE64) {
+                Log.d(TAG, "🔍 isLive=$isLive (DEBUG_FORCE_BASE64=$DEBUG_FORCE_BASE64) - generating 640x640 JPEG Base64...")
+                try {
+                    recognitionImageBase64 = generate640x640JpegBase64(nv21, width, height)
+                    if (recognitionImageBase64 != null) {
+                        Log.d(TAG, " Generated 640x640 JPEG Base64 for recognition API (size: ${recognitionImageBase64.length} bytes)")
+                    } else {
+                        Log.w(TAG, " generate640x640JpegBase64 returned null")
+                    }
+                } catch (e: Exception) {
+                    Log.w(TAG, " Failed to generate 640x640 JPEG Base64: ${e.message}", e)
+                    // Continue without the image - it's not critical
+                }
+            } else {
+                Log.d(TAG, " isLive is FALSE - skipping Base64 generation")
+            }
 
             AntiSpoofingResult(
                 neuralNetworkScore = nnScore,
                 laplacianScore = laplacianScore,
+                textureComplexity = textureScore,
+                temporalConsistency = temporalConsistency,
+                colorSaturation = colorSat,
                 combinedScore = combinedScore,
                 isLive = isLive,
-                label = if (isLive) "Live Face" else "Spoof Face"
+                confidence = confidence,
+                label = if (isLive) "Live Face" else "Spoof Face: ${spoofDetection.type}",
+                spoofType = spoofDetection.type,
+                recognitionImageBase64 = recognitionImageBase64
             )
         } catch (e: Exception) {
             Log.e(TAG, "Error in advancedAntiSpoofing", e)
-            AntiSpoofingResult(0f, 0, 0f, false, "Error: ${e.message}")
+            AntiSpoofingResult(0f, 0, 0, 0f, 0f, 0f, false, 0f, "Error: ${e.message}", "PROCESSING_ERROR")
         }
     }
 
     private fun neuralNetworkAntiSpoofing(nv21: ByteArray, width: Int, height: Int): Float {
         return try {
-            // Validate NV21 buffer before processing
             val expectedSize = width * height + (width * height) / 2
             if (nv21.size < expectedSize) {
                 throw IllegalArgumentException("NV21 buffer size mismatch: expected $expectedSize, got ${nv21.size}")
             }
 
-            // Convert NV21 YUV to RGB float array, resized to model input size
             if (rgbFloatBuffer == null || rgbFloatBuffer!!.size < INPUT_IMAGE_SIZE * INPUT_IMAGE_SIZE * 3) {
                 rgbFloatBuffer = FloatArray(INPUT_IMAGE_SIZE * INPUT_IMAGE_SIZE * 3)
             }
@@ -197,32 +261,87 @@ class FaceAntiSpoofingAdvanced(private val assetManager: AssetManager) {
                 throw Exception("RGB conversion returned empty array")
             }
 
-            // Fill reusable inputBuffer with normalized floats (row-major RGB)
             inputBuffer.rewind()
             for (i in 0 until (INPUT_IMAGE_SIZE * INPUT_IMAGE_SIZE * 3)) {
                 inputBuffer.putFloat(rgbFloats[i])
             }
             inputBuffer.rewind()
 
-            // Validate interpreter
             if (interpreter == null) {
                 throw Exception("Interpreter is null")
             }
 
-            // Reuse preallocated outputs map and arrays
             outputs[outputIndex0] = clssPred
             outputs[outputIndex1] = leafNodeMask
 
-            // Run model with ByteBuffer input (single input)
             interpreter!!.runForMultipleInputsOutputs(arrayOf<Any>(inputBuffer), outputs)
 
-            leafScore1(clssPred, leafNodeMask)
+            val rawScore = leafScore1(clssPred, leafNodeMask)
+            
+            // Apply non-linear scaling to make high scores more sensitive
+            applyNonLinearScaling(rawScore)
         } catch (e: Exception) {
             Log.e(TAG, "Error in neuralNetworkAntiSpoofing: ${e.message}", e)
             throw e
         }
     }
 
+    private fun applyNonLinearScaling(score: Float): Float {
+        // Exponential scaling to make scores > 0.1 much more sensitive
+        return if (score > 0.1f) {
+            score * (1 + (score - 0.1f) * 2.0f) // Amplify higher scores
+        } else {
+            score
+        }
+    }
+
+    /**
+     * Generate 640×640 JPEG image as Base64 string for Recognition API.
+     * Optimized for high-speed encoding without intermediate allocations.
+     *
+     * @param nv21 NV21 encoded YUV frame
+     * @param width Original frame width
+     * @param height Original frame height
+     * @return Base64 encoded JPEG string (640×640), or null if generation fails
+     */
+    private fun generate640x640JpegBase64(nv21: ByteArray, width: Int, height: Int): String? {
+        return try {
+            val TARGET_SIZE = 640
+            Log.d(TAG, "Starting 640x640 JPEG generation. Input: ${width}x${height}, NV21 size: ${nv21.size}")
+            
+            // Convert NV21 to RGB byte array directly (640×640)
+            val rgbBytes = ByteArray(TARGET_SIZE * TARGET_SIZE * 3)
+            Log.d(TAG, "Allocated RGB buffer: ${rgbBytes.size} bytes")
+            
+            val startConvert = System.currentTimeMillis()
+            val convertedRgb = yuvConverter.nv21ToRgbByteArray(
+                nv21, width, height,
+                TARGET_SIZE, TARGET_SIZE,
+                rgbBytes
+            )
+            val convertTime = System.currentTimeMillis() - startConvert
+            Log.d(TAG, "YUV to RGB conversion completed in ${convertTime}ms. RGB data: ${convertedRgb.size} bytes")
+
+            // Encode RGB to JPEG Base64 with quality 85
+            val startJpeg = System.currentTimeMillis()
+            val base64Result = JpegEncoder.rgbToJpegBase64(convertedRgb, TARGET_SIZE, TARGET_SIZE, quality = 85)
+            val jpegTime = System.currentTimeMillis() - startJpeg
+            
+            if (base64Result != null) {
+                Log.d(TAG, "JPEG encoding completed in ${jpegTime}ms. Base64 size: ${base64Result.length} bytes")
+                Log.d(TAG, " Generated 640x640 JPEG Base64 for recognition API (total: ${convertTime + jpegTime}ms)")
+            } else {
+                Log.w(TAG, " JpegEncoder returned null")
+            }
+            
+            base64Result
+        } catch (e: Exception) {
+            Log.e(TAG, " Error generating 640x640 JPEG Base64: ${e.message}", e)
+            e.printStackTrace()
+            null
+        }
+    }
+
     private fun leafScore1(clssPred: Array<FloatArray>, leafNodeMask: Array<FloatArray>): Float {
         var score = 0f
         for (i in 0 until 8) {
@@ -235,19 +354,17 @@ class FaceAntiSpoofingAdvanced(private val assetManager: AssetManager) {
         return try {
             calculateLaplacianScore(nv21, width, height)
         } catch (e: Exception) {
-            android.util.Log.e(TAG, "Error in laplacian calculation", e)
+            Log.e(TAG, "Error in laplacian calculation", e)
             throw e
         }
     }
 
     private fun calculateLaplacianScore(nv21: ByteArray, width: Int, height: Int): Int {
-        // Validate NV21 buffer
         val expectedSize = width * height + (width * height) / 2
         if (nv21.size < expectedSize) {
             throw IllegalArgumentException("NV21 buffer size mismatch for Laplacian: expected $expectedSize, got ${nv21.size}")
         }
 
-        // Convert to grayscale intensity array (resized to model input size)
         if (grayscaleBuffer == null || grayscaleBuffer!!.size < INPUT_IMAGE_SIZE * INPUT_IMAGE_SIZE) {
             grayscaleBuffer = IntArray(INPUT_IMAGE_SIZE * INPUT_IMAGE_SIZE)
         }
@@ -263,7 +380,6 @@ class FaceAntiSpoofingAdvanced(private val assetManager: AssetManager) {
         }
 
         var score = 0
-        // Apply 3x3 laplacian kernel without extra allocation
         for (y in 1 until INPUT_IMAGE_SIZE - 1) {
             val rowOffset = y * INPUT_IMAGE_SIZE
             for (x in 1 until INPUT_IMAGE_SIZE - 1) {
@@ -280,9 +396,199 @@ class FaceAntiSpoofingAdvanced(private val assetManager: AssetManager) {
         return score
     }
 
-    private fun calculateCombinedScore(neuralScore: Float, laplacianScore: Int): Float {
+    private fun calculateTextureComplexity(nv21: ByteArray, width: Int, height: Int): Int {
+        // Enhanced texture analysis using multiple filters
+        if (grayscaleBuffer == null || grayscaleBuffer!!.size < INPUT_IMAGE_SIZE * INPUT_IMAGE_SIZE) {
+            grayscaleBuffer = IntArray(INPUT_IMAGE_SIZE * INPUT_IMAGE_SIZE)
+        }
+        
+        val grayscale = yuvConverter.nv21ToGrayscaleIntArray(
+            nv21, width, height,
+            INPUT_IMAGE_SIZE, INPUT_IMAGE_SIZE,
+            grayscaleBuffer
+        ) ?: return 0
+
+        var complexity = 0
+        
+        // Sobel edge detection for texture analysis
+        for (y in 1 until INPUT_IMAGE_SIZE - 1) {
+            val rowOffset = y * INPUT_IMAGE_SIZE
+            for (x in 1 until INPUT_IMAGE_SIZE - 1) {
+                val gx = (-1 * grayscale[rowOffset - INPUT_IMAGE_SIZE + x - 1] +
+                          1 * grayscale[rowOffset - INPUT_IMAGE_SIZE + x + 1] +
+                          -2 * grayscale[rowOffset + x - 1] +
+                          2 * grayscale[rowOffset + x + 1] +
+                          -1 * grayscale[rowOffset + INPUT_IMAGE_SIZE + x - 1] +
+                          1 * grayscale[rowOffset + INPUT_IMAGE_SIZE + x + 1])
+                
+                val gy = (-1 * grayscale[rowOffset - INPUT_IMAGE_SIZE + x - 1] +
+                          -2 * grayscale[rowOffset - INPUT_IMAGE_SIZE + x] +
+                          -1 * grayscale[rowOffset - INPUT_IMAGE_SIZE + x + 1] +
+                          1 * grayscale[rowOffset + INPUT_IMAGE_SIZE + x - 1] +
+                          2 * grayscale[rowOffset + INPUT_IMAGE_SIZE + x] +
+                          1 * grayscale[rowOffset + INPUT_IMAGE_SIZE + x + 1])
+                
+                val gradient = sqrt((gx * gx + gy * gy).toDouble()).toInt()
+                if (gradient > 50) complexity++
+            }
+        }
+        
+        return complexity
+    }
+
+    private fun calculateColorSaturation(nv21: ByteArray, width: Int, height: Int): Float {
+        // Calculate average color saturation to detect printed attacks
+        val uvStart = width * height
+        var totalSaturation = 0f
+        var sampleCount = 0
+        
+        for (i in uvStart until nv21.size step 2) {
+            val u = (nv21[i].toInt() and 0xFF) - 128
+            val v = (nv21[i + 1].toInt() and 0xFF) - 128
+            val saturation = sqrt((u * u + v * v).toDouble()).toFloat()
+            totalSaturation += saturation
+            sampleCount++
+        }
+        
+        return if (sampleCount > 0) totalSaturation / sampleCount / 128.0f else 0f
+    }
+
+    private fun calculateTemporalConsistency(currentScore: Float): Float {
+        // Analyze score consistency over time
+        scoreHistory.addFirst(currentScore)
+        if (scoreHistory.size > HISTORY_SIZE) {
+            scoreHistory.removeLast()
+        }
+        
+        if (scoreHistory.size < MIN_FRAMES_FOR_ANALYSIS) {
+            return 1.0f // Maximum consistency initially
+        }
+        
+        // Calculate variance of recent scores
+        val mean = scoreHistory.average().toFloat()
+        val variance = scoreHistory.map { (it - mean) * (it - mean) }.average().toFloat()
+        
+        // Convert variance to consistency score (lower variance = higher consistency)
+        return max(0f, 1.0f - (variance / SCORE_VARIANCE_THRESHOLD))
+    }
+
+    private fun updateAdaptiveThreshold(nv21: ByteArray, width: Int, height: Int) {
+        // Adjust threshold based on environmental factors
+        val brightness = calculateBrightness(nv21, width, height)
+        val currentTime = System.currentTimeMillis()
+        
+        if (currentTime - environmentAssessment.lastAssessmentTime > 1000) { // Assess every second
+            environmentAssessment.avgBrightness = brightness
+            environmentAssessment.lastAssessmentTime = currentTime
+            
+            // Make threshold more strict in good lighting conditions
+            adaptiveThreshold = if (brightness > 0.6f) {
+                BASE_THRESHOLD * 0.8f  // Stricter in good light
+            } else if (brightness < 0.3f) {
+                BASE_THRESHOLD * 1.2f  // Slightly more lenient in poor light
+            } else {
+                BASE_THRESHOLD
+            }
+        }
+    }
+
+    private fun calculateBrightness(nv21: ByteArray, width: Int, height: Int): Float {
+        // Calculate average brightness from Y channel
+        var totalLuma = 0f
+        for (i in 0 until width * height) {
+            totalLuma += (nv21[i].toInt() and 0xFF) / 255.0f
+        }
+        return totalLuma / (width * height)
+    }
+
+    data class SpoofDetectionResult(
+        val type: String,
+        val confidence: Float
+    )
+
+    private fun detectSpoofType(
+        nnScore: Float, 
+        laplacianScore: Int, 
+        textureScore: Int, 
+        colorSat: Float, 
+        temporalConsistency: Float
+    ): SpoofDetectionResult {
+        
+        // Detect specific spoof types based on feature patterns
+        return when {
+            // Printed photo detection (low texture, low laplacian)
+            textureScore < TEXTURE_COMPLEXITY_THRESHOLD * 0.6 && 
+            laplacianScore < LAPLACIAN_THRESHOLD * 0.7 -> 
+                SpoofDetectionResult("PRINTED_PHOTO", 0.8f)
+            
+            // Screen replay detection (high color saturation, medium texture)
+            colorSat > COLOR_SATURATION_THRESHOLD * 1.2 && 
+            textureScore > TEXTURE_COMPLEXITY_THRESHOLD * 0.8 -> 
+                SpoofDetectionResult("SCREEN_REPLAY", 0.7f)
+            
+            // 3D mask detection (medium scores across all features)
+            nnScore > BASE_THRESHOLD * 1.5 && 
+            temporalConsistency < 0.7f -> 
+                SpoofDetectionResult("3D_MASK", 0.6f)
+            
+            // General spoof
+            nnScore > BASE_THRESHOLD -> 
+                SpoofDetectionResult("GENERAL_SPOOF", 0.9f)
+            
+            else -> SpoofDetectionResult("UNKNOWN", 0.5f)
+        }
+    }
+
+    private fun calculateConfidence(
+        nnScore: Float, 
+        laplacianScore: Int, 
+        textureScore: Int, 
+        temporalConsistency: Float
+    ): Float {
+        val nnConfidence = 1.0f - (nnScore / BASE_THRESHOLD).coerceIn(0f, 1f)
+        val textureConfidence = (textureScore.toFloat() / TEXTURE_COMPLEXITY_THRESHOLD).coerceIn(0f, 1f)
+        val laplacianConfidence = (laplacianScore.toFloat() / LAPLACIAN_THRESHOLD).coerceIn(0f, 1f)
+        
+        return (nnConfidence * 0.4f + textureConfidence * 0.3f + 
+                laplacianConfidence * 0.2f + temporalConsistency * 0.1f)
+    }
+
+    private fun calculateCombinedScore(
+        neuralScore: Float, 
+        laplacianScore: Int, 
+        textureScore: Int, 
+        temporalConsistency: Float
+    ): Float {
         val normalizedLaplacian = laplacianScore.toFloat() / LAPLACIAN_THRESHOLD
-        return (1 - neuralScore) * 0.7f + (normalizedLaplacian * 0.3f)
+        val normalizedTexture = textureScore.toFloat() / TEXTURE_COMPLEXITY_THRESHOLD
+        
+        return (1 - neuralScore) * 0.5f + 
+               normalizedLaplacian * 0.25f + 
+               normalizedTexture * 0.15f + 
+               temporalConsistency * 0.1f
+    }
+
+    private fun isLiveFace(
+        nnScore: Float,
+        laplacianScore: Int,
+        textureScore: Int,
+        colorSat: Float,
+        temporalConsistency: Float,
+        spoofDetection: SpoofDetectionResult
+    ): Boolean {
+        
+        // Multi-layered spoof detection
+        val layer1 = nnScore < adaptiveThreshold
+        val layer2 = laplacianScore > LAPLACIAN_THRESHOLD
+        val layer3 = textureScore > TEXTURE_COMPLEXITY_THRESHOLD
+        val layer4 = temporalConsistency > 0.7f
+        val layer5 = colorSat < COLOR_SATURATION_THRESHOLD * 1.5f
+        
+        // Require majority of layers to pass, with neural network score being most important
+        val passedLayers = listOf(layer1, layer2, layer3, layer4, layer5).count { it }
+        
+        // Stricter requirement: must pass at least 4 out of 5 layers, including neural network
+        return passedLayers >= 4 && layer1
     }
 
     @Throws(IOException::class)
@@ -297,23 +603,28 @@ class FaceAntiSpoofingAdvanced(private val assetManager: AssetManager) {
                 fileDescriptor.declaredLength
             )
         } catch (e: Exception) {
-            android.util.Log.e(TAG, "Error loading model file", e)
+            Log.e(TAG, "Error loading model file", e)
             throw e
         }
     }
 
     fun isInitialized(): Boolean = isInitialized
 
+    fun resetHistory() {
+        scoreHistory.clear()
+        laplacianHistory.clear()
+        frameCount = 0
+        adaptiveThreshold = BASE_THRESHOLD
+    }
+
     fun close() {
         try {
             interpreter?.close()
             interpreter = null
-            
-            // Clean up GPU delegate
             gpuDelegate?.close()
             gpuDelegate = null
-            
             currentAccelerator = ACCELERATOR_CPU
+            resetHistory()
             Log.i(TAG, "Interpreter and delegates closed successfully")
         } catch (e: Exception) {
             Log.e(TAG, "Error closing interpreter", e)
@@ -324,7 +635,13 @@ class FaceAntiSpoofingAdvanced(private val assetManager: AssetManager) {
 data class AntiSpoofingResult(
     val neuralNetworkScore: Float,
     val laplacianScore: Int,
+    val textureComplexity: Int,
+    val temporalConsistency: Float,
+    val colorSaturation: Float,
     val combinedScore: Float,
     val isLive: Boolean,
-    val label: String
-)
+    val confidence: Float,
+    val label: String,
+    val spoofType: String,
+    val recognitionImageBase64: String? = null
+)