react-native-vision-camera-spoof-detector 1.0.7 → 1.0.9

package/android/build/intermediates/incremental/debug/packageDebugResources/compile-file-map.properties

@@ -1 +1 @@
-#Tue Nov 25 20:14:46 IST 2025
+#Thu Nov 27 10:59:27 IST 2025

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

@@ -3,12 +3,14 @@ package com.faceantispoof
 /**
  * Configuration class for TensorFlow Lite accelerators
  * Allows developers to control GPU/NNAPI delegate behavior
+ * and optimize for different device tiers (low-end, mid-range, high-end)
  */
 object AcceleratorConfig {
     
     /**
      * Enable GPU acceleration (recommended for modern devices)
      * Accelerates model 3-10x compared to CPU
+     * GPU is automatically skipped on low-end devices even if enabled
      */
     var enableGpu: Boolean = true
     
@@ -16,34 +18,80 @@ object AcceleratorConfig {
      * Enable NNAPI acceleration (recommended for Pixel/Samsung devices)
      * Accelerates model 3-10x compared to CPU
      * Fallback if GPU is not available
+     * Works better on mid-range and high-end devices
      */
     var enableNnapi: Boolean = true
     
     /**
      * Enable CPU fallback if GPU/NNAPI are not available
-     * Default: true
+     * Default: true (always fallback to CPU)
      */
     var enableCpuFallback: Boolean = true
     
     /**
      * Number of threads for CPU inference
-     * Default: 4 threads
+     * Default: 4 threads (optimal for most devices)
+     * Low-end devices will use 1-2 threads regardless
      */
     var cpuThreadCount: Int = 4
     
     /**
-     * Print debug logs for accelerator selection
+     * Force CPU-only mode for all devices
+     * Useful for debugging or if GPU/NNAPI causes issues
+     * Default: false
+     */
+    var forceCpuOnly: Boolean = false
+    
+    /**
+     * Disable GPU delegate specifically
+     * Keeps NNAPI enabled if available
+     * Default: false
+     */
+    var disableGpuDelegate: Boolean = false
+    
+    /**
+     * Disable NNAPI delegate specifically
+     * GPU will still be attempted if enabled
+     * Default: false
+     */
+    var disableNnapiDelegate: Boolean = false
+    
+    /**
+     * Print debug logs for accelerator selection and performance
+     * Default: true
      */
     var debugLogging: Boolean = true
     
+    /**
+     * Enable aggressive optimization for low-end devices
+     * Reduces memory usage and processes fewer frames
+     * Default: true
+     */
+    var optimizeForLowEndDevices: Boolean = true
+    
+    /**
+     * Maximum memory (in MB) to allocate for the interpreter
+     * Low-end devices will use less aggressive settings
+     * Default: 0 (use system defaults)
+     */
+    var maxMemoryAllocation: Int = 0
+    
     override fun toString(): String {
         return """
-            AcceleratorConfig:
-            - GPU Enabled: $enableGpu
-            - NNAPI Enabled: $enableNnapi
-            - CPU Fallback: $enableCpuFallback
-            - CPU Threads: $cpuThreadCount
-            - Debug Logging: $debugLogging
+            ╔════════════════════════════════════════════════╗
+            ║        TFLite Accelerator Configuration        ║
+            ╠════════════════════════════════════════════════╣
+            ║ GPU Acceleration:        $enableGpu
+            ║ NNAPI Acceleration:      $enableNnapi
+            ║ CPU Fallback:            $enableCpuFallback
+            ║ CPU Threads:             $cpuThreadCount
+            ║ Force CPU Only:          $forceCpuOnly
+            ║ Disable GPU Delegate:    $disableGpuDelegate
+            ║ Disable NNAPI Delegate:  $disableNnapiDelegate
+            ║ Debug Logging:           $debugLogging
+            ║ Optimize Low-End:        $optimizeForLowEndDevices
+            ║ Max Memory (MB):         $maxMemoryAllocation
+            ╚════════════════════════════════════════════════╝
         """.trimIndent()
     }
 }

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

@@ -34,10 +34,10 @@ class FaceAntiSpoofingAdvanced(private val assetManager: AssetManager) {
         const val ACCELERATOR_GPU = "GPU"
         const val ACCELERATOR_NNAPI = "NNAPI"
         
-        // Image format configuration for face recognition systems
-        // Supported: JPEG (compressed), PNG (lossless), BMP (uncompressed)
+        // ENHANCED IMAGE FORMAT CONFIGURATION FOR FACE RECOGNITION
+        // Optimized for maximum quality for face detection APIs
         const val DEFAULT_IMAGE_FORMAT = "JPEG"  // Options: "JPEG", "PNG", "BMP"
-        const val DEFAULT_JPEG_QUALITY = 85      // 0-100, higher = better quality but larger
+        const val DEFAULT_JPEG_QUALITY = 92      // Increased from 85 to 92 for better quality
         const val DEFAULT_OUTPUT_RESOLUTION = 640 // 640×640 for face recognition
         
         // Advanced spoof detection constants
@@ -49,6 +49,11 @@ class FaceAntiSpoofingAdvanced(private val assetManager: AssetManager) {
         private const val TEXTURE_COMPLEXITY_THRESHOLD = 800
         private const val COLOR_SATURATION_THRESHOLD = 0.4f
         private const val DEPTH_VARIATION_THRESHOLD = 0.1f
+        
+        // STABILITY ENHANCEMENT CONSTANTS
+        private const val BLUR_DETECTION_THRESHOLD = 100  // Laplacian score threshold
+        private const val MIN_STABLE_FRAMES = 3  // Require stable frames before generating base64
+        private const val MOTION_THRESHOLD = 0.1f  // Limit motion/instability
     }
 
     private var interpreter: Interpreter? = null
@@ -79,6 +84,12 @@ class FaceAntiSpoofingAdvanced(private val assetManager: AssetManager) {
     private var frameCount = 0
     private var adaptiveThreshold = BASE_THRESHOLD
     private var environmentAssessment = EnvironmentAssessment()
+    
+    // STABILITY AND QUALITY TRACKING
+    private var consecutiveQualityFrames = 0  // Track consecutive high-quality frames
+    private var lastStableFrameTime = System.currentTimeMillis()
+    private var lastProcessedBlurScore = 0
+    private var frameStabilityScore = 0f
 
     data class EnvironmentAssessment(
         var avgBrightness: Float = 0f,
@@ -96,22 +107,15 @@ class FaceAntiSpoofingAdvanced(private val assetManager: AssetManager) {
         try {
             val modelBuffer = loadModelFile(assetManager, MODEL_FILE)
             val options = Interpreter.Options()
-            options.setNumThreads(4)
             
-            if (tryAddGpuDelegate(options)) {
-                currentAccelerator = ACCELERATOR_GPU
-                Log.i(TAG, "GPU delegate enabled successfully")
-            } 
-            else {
-                try {
-                    options.setUseNNAPI(true)
-                    currentAccelerator = ACCELERATOR_NNAPI
-                    Log.i(TAG, "NNAPI enabled successfully")
-                } catch (e: Exception) {
-                    currentAccelerator = ACCELERATOR_CPU
-                    Log.i(TAG, "Running on CPU (GPU/NNAPI not available): ${e.message}")
-                }
-            }
+            // FORCE CPU-ONLY MODE FOR LOW-END DEVICE COMPATIBILITY
+            // This bypasses all GPU/NNAPI issues and uses stable CPU inference
+            val optimalThreads = getOptimalThreadCount()
+            options.setNumThreads(optimalThreads)
+            
+            currentAccelerator = ACCELERATOR_CPU
+            Log.i(TAG, "✓ FORCED CPU-ONLY MODE - Bypassing GPU/NNAPI")
+            Log.i(TAG, "Using $optimalThreads threads for CPU inference")
             
             interpreter = Interpreter(modelBuffer, options)
             
@@ -126,28 +130,46 @@ class FaceAntiSpoofingAdvanced(private val assetManager: AssetManager) {
             outputs[outputIndex0] = clssPred
             outputs[outputIndex1] = leafNodeMask
             isInitialized = true
-            Log.i(TAG, "Interpreter initialized with accelerator: $currentAccelerator")
+            Log.i(TAG, "✓ Face Anti-Spoof initialized | CPU-ONLY MODE | Threads: $optimalThreads")
         } catch (e: Exception) {
-            Log.e(TAG, "Failed to load TFLite model", e)
+            Log.e(TAG, "✗ Failed to load TFLite model: ${e.message}", e)
             isInitialized = false
+            currentAccelerator = ACCELERATOR_CPU
         }
     }
 
     private fun tryAddGpuDelegate(options: Interpreter.Options): Boolean {
         return try {
+            // Additional check: verify device has minimum Android version for GPU delegate
+            if (android.os.Build.VERSION.SDK_INT < android.os.Build.VERSION_CODES.LOLLIPOP) {
+                Log.w(TAG, "GPU delegate requires Android 5.0+, device running: ${android.os.Build.VERSION.SDK_INT}")
+                return false
+            }
+            
             val compatibilityList = CompatibilityList()
             if (compatibilityList.isDelegateSupportedOnThisDevice) {
-                gpuDelegate = GpuDelegate(compatibilityList.bestOptionsForThisDevice)
-                options.addDelegate(gpuDelegate)
-                Log.d(TAG, "GPU delegate added successfully")
-                true
+                try {
+                    gpuDelegate = GpuDelegate(compatibilityList.bestOptionsForThisDevice)
+                    options.addDelegate(gpuDelegate)
+                    Log.d(TAG, "GPU delegate added successfully")
+                    true
+                } catch (e: Exception) {
+                    Log.w(TAG, "Failed to initialize GPU delegate after compatibility check: ${e.message}")
+                    gpuDelegate?.close()
+                    gpuDelegate = null
+                    false
+                }
             } else {
                 Log.d(TAG, "GPU delegate not supported on this device")
                 false
             }
         } catch (e: Exception) {
             Log.w(TAG, "Failed to add GPU delegate: ${e.message}")
-            gpuDelegate?.close()
+            try {
+                gpuDelegate?.close()
+            } catch (e2: Exception) {
+                Log.w(TAG, "Error closing GPU delegate: ${e2.message}")
+            }
             gpuDelegate = null
             false
         }
@@ -274,21 +296,47 @@ class FaceAntiSpoofingAdvanced(private val assetManager: AssetManager) {
             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 ${outputImageResolution}×${outputImageResolution} $outputImageFormat Base64...")
+            // STABILITY CHECK: Only generate base64 for high-quality, stable frames
+            val isQualityFrame = laplacianScore > BLUR_DETECTION_THRESHOLD && 
+                                temporalConsistency < MOTION_THRESHOLD &&
+                                textureScore > TEXTURE_COMPLEXITY_THRESHOLD / 2
+            
+            if (isQualityFrame) {
+                consecutiveQualityFrames++
+                frameStabilityScore = (laplacianScore.toFloat() / 1000f).coerceIn(0f, 1f)
+            } else {
+                consecutiveQualityFrames = 0
+                frameStabilityScore = 0f
+            }
+            
+            // Only generate base64 after collecting stable frames
+            val shouldGenerateBase64 = (isLive && (consecutiveQualityFrames >= MIN_STABLE_FRAMES || DEBUG_FORCE_BASE64)) ||
+                                       DEBUG_FORCE_BASE64
+            
+            if (shouldGenerateBase64) {
+                Log.d(TAG, "🔍 Quality Frame Detected - Stability Score: $frameStabilityScore (${consecutiveQualityFrames}/$MIN_STABLE_FRAMES frames)")
+                Log.d(TAG, "   Blur Score: $laplacianScore (threshold: $BLUR_DETECTION_THRESHOLD)")
+                Log.d(TAG, "   Motion: $temporalConsistency (threshold: $MOTION_THRESHOLD)")
+                Log.d(TAG, "   Texture: $textureScore (min: ${TEXTURE_COMPLEXITY_THRESHOLD / 2})")
+                
                 try {
                     recognitionImageBase64 = generateRecognitionImageBase64(nv21, width, height)
                     if (recognitionImageBase64 != null) {
-                        Log.d(TAG, " Generated 640x640 JPEG Base64 for recognition API (size: ${recognitionImageBase64.length} bytes)")
+                        Log.d(TAG, "✅ Generated 640x640 JPEG Base64 for recognition API (size: ${recognitionImageBase64.length} bytes)")
                     } else {
-                        Log.w(TAG, " generate640x640JpegBase64 returned null")
+                        Log.w(TAG, "⚠️ generateRecognitionImageBase64 returned null")
                     }
                 } catch (e: Exception) {
-                    Log.w(TAG, " Failed to generate 640x640 JPEG Base64: ${e.message}", e)
+                    Log.w(TAG, "❌ Failed to generate Base64: ${e.message}", e)
                     // Continue without the image - it's not critical
                 }
             } else {
-                Log.d(TAG, " isLive is FALSE - skipping Base64 generation")
+                if (!isLive) {
+                    Log.d(TAG, "🚫 Not generating Base64 - Spoof detected (${spoofDetection.type})")
+                } else {
+                    Log.d(TAG, "🚫 Waiting for stable frames... (${consecutiveQualityFrames}/$MIN_STABLE_FRAMES)")
+                    Log.d(TAG, "   Quality Score: $frameStabilityScore | Blur: $laplacianScore | Motion: $temporalConsistency")
+                }
             }
 
             AntiSpoofingResult(
@@ -386,6 +434,13 @@ class FaceAntiSpoofingAdvanced(private val assetManager: AssetManager) {
 
     /**
      * Generate image as Base64 string for face recognition API.
+     * 
+     * QUALITY ENHANCEMENTS:
+     * - Uses bilinear interpolation for smooth resizing (no blur artifacts)
+     * - Applies unsharp masking for edge enhancement
+     * - Uses quality 92 JPEG encoding (up from 85) for better face detection
+     * - Validates frame stability before generation
+     *
      * Supports JPEG, PNG, and BMP formats with configurable resolution.
      * Compatible with OpenCV cv2.imdecode() for face recognition systems.
      *
@@ -396,9 +451,10 @@ class FaceAntiSpoofingAdvanced(private val assetManager: AssetManager) {
      */
     private fun generateRecognitionImageBase64(nv21: ByteArray, width: Int, height: Int): String? {
         return try {
-            Log.d(TAG, "Starting ${outputImageResolution}×${outputImageResolution} $outputImageFormat generation. Input: ${width}x${height}, NV21 size: ${nv21.size}")
+            Log.d(TAG, "Starting HIGH-QUALITY ${outputImageResolution}×${outputImageResolution} $outputImageFormat generation...")
+            Log.d(TAG, "Input: ${width}x${height}, JPEG Quality: $outputImageQuality (optimized for face detection)")
             
-            // Convert NV21 to RGB byte array directly (configurable resolution)
+            // Convert NV21 to RGB byte array using HIGH-QUALITY BILINEAR interpolation
             val rgbBytes = ByteArray(outputImageResolution * outputImageResolution * 3)
             Log.d(TAG, "Allocated RGB buffer: ${rgbBytes.size} bytes")
             
@@ -409,10 +465,13 @@ class FaceAntiSpoofingAdvanced(private val assetManager: AssetManager) {
                 rgbBytes
             )
             val convertTime = System.currentTimeMillis() - startConvert
-            Log.d(TAG, "YUV to RGB conversion completed in ${convertTime}ms. RGB data: ${convertedRgb.size} bytes")
+            Log.d(TAG, "✓ YUV→RGB conversion (bilinear): ${convertTime}ms | ${convertedRgb.size} bytes")
 
-            // Encode RGB to target format (JPEG, PNG, or BMP) and Base64
-            // NOTE: ImageFormatEncoder.rgbToBase64() automatically converts RGB→BGR for OpenCV compatibility
+            // Encode RGB to target format with sharpening
+            // NOTE: ImageFormatEncoder.rgbToBase64() automatically:
+            //   - Applies unsharp masking for edge enhancement
+            //   - Converts RGB→BGR for OpenCV compatibility
+            //   - Uses optimized JPEG quality
             val startEncode = System.currentTimeMillis()
             val format = when (outputImageFormat) {
                 "PNG" -> ImageFormatEncoder.ImageFormat.PNG
@@ -425,17 +484,22 @@ class FaceAntiSpoofingAdvanced(private val assetManager: AssetManager) {
                 outputImageResolution, 
                 outputImageResolution,
                 format,
-                outputImageQuality
+                outputImageQuality  // Using quality 92 for better face detection
             )
             val encodeTime = System.currentTimeMillis() - startEncode
             
             if (base64Result != null) {
-                Log.d(TAG, "$outputImageFormat encoding completed in ${encodeTime}ms. Base64 size: ${base64Result.length} bytes")
-                Log.d(TAG, "✅ Generated ${outputImageResolution}×${outputImageResolution} $outputImageFormat Base64 for recognition API in BGR format (total: ${convertTime + encodeTime}ms)")
+                Log.d(TAG, "✓ $outputImageFormat encoding (with sharpening): ${encodeTime}ms")
+                Log.d(TAG, "✅ HIGH-QUALITY Base64 Generated:")
+                Log.d(TAG, "   Resolution: ${outputImageResolution}×${outputImageResolution}")
+                Log.d(TAG, "   Format: $outputImageFormat (BGR for OpenCV)")
+                Log.d(TAG, "   Quality: $outputImageQuality (enhanced for face recognition)")
+                Log.d(TAG, "   Size: ${base64Result.length} chars (est. ${base64Result.length * 0.75 / 1024}KB)")
+                Log.d(TAG, "   Total Time: ${convertTime + encodeTime}ms")
                 val estSize = estimateImageSize()
-                Log.d(TAG, "Format: $outputImageFormat (BGR), Quality: $outputImageQuality, Estimated: ${estSize / 1024}KB")
+                Log.d(TAG, "   Estimated: ${estSize / 1024}KB")
             } else {
-                Log.w(TAG, "⚠️ ImageFormatEncoder returned null for BGR conversion")
+                Log.w(TAG, "⚠️ ImageFormatEncoder returned null")
             }
             
             base64Result
@@ -772,6 +836,88 @@ class FaceAntiSpoofingAdvanced(private val assetManager: AssetManager) {
             Log.e(TAG, "Error closing interpreter", e)
         }
     }
+
+    /**
+     * Detects if the device is high-end based on RAM, processor, and Android version.
+     * High-end devices can use GPU/NNAPI delegates.
+     * Low-end devices default to optimized CPU inference.
+     */
+    private fun isHighEndDevice(): Boolean {
+        try {
+            // Check Android version
+            if (android.os.Build.VERSION.SDK_INT < android.os.Build.VERSION_CODES.LOLLIPOP) {
+                Log.d(TAG, "Device running Android ${android.os.Build.VERSION.SDK_INT} (< 5.0) - low-end")
+                return false
+            }
+            
+            // Check available RAM
+            val runtime = Runtime.getRuntime()
+            val maxMemory = runtime.maxMemory() / (1024 * 1024) // Convert to MB
+            if (maxMemory < 256) { // Less than 256MB allocated
+                Log.d(TAG, "Low available RAM: ${maxMemory}MB - treating as low-end device")
+                return false
+            }
+            
+            // Check processor cores (devices with 2 cores or less are typically low-end)
+            val processorCount = Runtime.getRuntime().availableProcessors()
+            if (processorCount <= 2) {
+                Log.d(TAG, "Limited CPU cores: $processorCount - low-end device")
+                return false
+            }
+            
+            // Check device name for known low-end models
+            val model = android.os.Build.MODEL.lowercase()
+            val lowEndMarkers = listOf(
+                "moto g", "samsung a", "samsung j", "redmi 6", "redmi 7", 
+                "honor 8a", "galaxy a01", "galaxy j2"
+            )
+            
+            for (marker in lowEndMarkers) {
+                if (model.contains(marker)) {
+                    Log.d(TAG, "Known low-end device model: ${android.os.Build.MODEL}")
+                    return false
+                }
+            }
+            
+            Log.d(TAG, "Device appears to be high-end (Android ${android.os.Build.VERSION.SDK_INT}, $processorCount cores, ${maxMemory}MB RAM)")
+            return true
+        } catch (e: Exception) {
+            Log.w(TAG, "Error detecting device tier: ${e.message}, defaulting to CPU-only")
+            return false
+        }
+    }
+
+    /**
+     * Calculates optimal thread count based on available processors and device resources.
+     * Low-end devices use 1-2 threads to avoid memory issues.
+     */
+    private fun getOptimalThreadCount(): Int {
+        return try {
+            val availableProcessors = Runtime.getRuntime().availableProcessors()
+            
+            // For low-end devices, limit thread count
+            if (!isHighEndDevice()) {
+                Log.d(TAG, "Low-end device: limiting threads to 1-2")
+                return maxOf(1, minOf(2, availableProcessors - 1))
+            }
+            
+            // For high-end devices, use configured count or optimal calculation
+            val configured = AcceleratorConfig.cpuThreadCount
+            val optimal = maxOf(1, availableProcessors - 1)
+            
+            val threadCount = if (configured > 0) {
+                minOf(configured, availableProcessors)
+            } else {
+                optimal
+            }
+            
+            Log.d(TAG, "Optimal thread count: $threadCount (available processors: $availableProcessors)")
+            threadCount
+        } catch (e: Exception) {
+            Log.w(TAG, "Error calculating optimal threads: ${e.message}, using default")
+            AcceleratorConfig.cpuThreadCount
+        }
+    }
 }
 
 data class AntiSpoofingResult(