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

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

@@ -96,22 +96,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 +119,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
         }
@@ -772,6 +783,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(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-vision-camera-spoof-detector",
-  "version": "1.0.7",
+  "version": "1.0.8",
   "description": "High-performance face anti-spoofing and liveness detection module for React Native Vision Camera. Uses TensorFlow Lite with GPU acceleration and optimized YUV processing.",
   "homepage": "https://github.com/jescon-tech/react-native-vision-camera-spoof-detector",
   "repository": {

package/android/build/intermediates/cxx/Debug/2a1it684/logs/arm64-v8a/generate_cxx_metadata_456_timing.txt

@@ -1,9 +0,0 @@
-# C/C++ build system timings
-generate_cxx_metadata
-  execute-generate-process
-    exec-configure 718ms
-    [gap of 21ms]
-  execute-generate-process completed in 741ms
-  [gap of 17ms]
-generate_cxx_metadata completed in 767ms
-

package/android/build/intermediates/cxx/Debug/2a1it684/logs/x86_64/generate_cxx_metadata_455_timing.txt

@@ -1,9 +0,0 @@
-# C/C++ build system timings
-generate_cxx_metadata
-  execute-generate-process
-    exec-configure 486ms
-    [gap of 23ms]
-  execute-generate-process completed in 511ms
-  [gap of 20ms]
-generate_cxx_metadata completed in 541ms
-