react-native-vision-camera-spoof-detector 1.0.16 → 1.0.18

package/LICENSE

@@ -0,0 +1,21 @@
+License
+
+Copyright (c) 2024 JESCON TECHNOLOGIES PVT LTD
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,220 +1,138 @@
-# React Native Vision Camera Face Anti-Spoofing Detector
-
-[![npm version](https://img.shields.io/npm/v/react-native-vision-camera-spoof-detector.svg)](https://www.npmjs.com/package/react-native-vision-camera-spoof-detector)
-[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
-
-High-performance **face anti-spoofing and liveness detection** module for React Native with Vision Camera integration. Uses TensorFlow Lite with GPU acceleration for real-time detection.
-
-## Features
-
-✅ **Real-time Face Liveness Detection** - Distinguish between live faces and spoofed images/videos  
-✅ **GPU Acceleration** - TensorFlow Lite GPU delegate support  
-✅ **NNAPI Support** - Hardware acceleration fallback for older devices  
-✅ **Multi-Threading** - Non-blocking background processing  
-✅ **Optimized YUV Processing** - Direct frame processing without Bitmap conversion  
-✅ **TypeScript Support** - Full type definitions included  
-✅ **Lightweight** - Only 20.92 MB (optimized build)  
-✅ **Production Ready** - Tested and stable  
-
-## Installation
-
-```bash
-npm install react-native-vision-camera-spoof-detector
-# or
-yarn add react-native-vision-camera-spoof-detector
-```
-
-### Peer Dependencies
-
-This module requires the following peer dependencies:
-
-```bash
-npm install react-native-vision-camera react-native-reanimated react-native-worklets-core
-```
-
-## Quick Start
-
-### 1. Initialize the Module
-
-```javascript
-import { initializeFaceAntiSpoof } from 'react-native-vision-camera-spoof-detector';
-
-// In your app initialization
-useEffect(() => {
-  initializeFaceAntiSpoof()
-    .then(() => console.log('Face anti-spoof initialized'))
-    .catch(err => console.error('Init failed:', err));
-}, []);
-```
-
-### 2. Use in Frame Processor
-
-```javascript
-import { useFrameProcessor } from 'react-native-vision-camera';
-import { faceAntiSpoofFrameProcessor } from 'react-native-vision-camera-spoof-detector';
-
-export function CameraScreen() {
-  const frameProcessor = useFrameProcessor((frame) => {
-    'worklet';
-    
-    const result = runAsync(frame, () => {
-      'worklet';
-      return faceAntiSpoofFrameProcessor(frame);
-    });
-    
-    // Use the result
-    if (result?.isLive) {
-      console.log('Live face detected:', result.label);
-    }
-  }, []);
-
-  return (
-    <Camera
-      device={device}
-      frameProcessor={frameProcessor}
-      // ... other props
-    />
-  );
-}
-```
-
-## API Reference
-
-### `initializeFaceAntiSpoof(): Promise<boolean>`
-
-Initializes the face anti-spoofing module. Must be called before using the frame processor.
-
-**Returns:** `Promise<boolean>` - true if initialization was successful
-
-```javascript
-const isInitialized = await initializeFaceAntiSpoof();
-```
-
-### `faceAntiSpoofFrameProcessor(frame): FaceAntiSpoofingResult | null`
-
-Process a camera frame for face anti-spoofing detection.
-
-**Parameters:**
-- `frame` (Frame) - Vision Camera frame object
-
-**Returns:** 
-```typescript
-{
-  isLive: boolean;           // true if face is live
-  label: string;             // "Live Face" or "Spoof Face"
-  neuralNetworkScore: number; // 0.0-1.0 (lower = more likely live)
-  laplacianScore: number;    // Image quality metric
-  combinedScore: number;     // 0.0-1.0 weighted score
-  error?: string;            // Error message if any
-}
-```
-
-### `isFaceAntiSpoofAvailable(): boolean`
-
-Check if the native module is available.
-
-```javascript
-const available = isFaceAntiSpoofAvailable();
-```
-
-## Performance
-
-### Optimization Techniques
-
-- **Multi-Threading**: Heavy processing runs on a dedicated background thread, keeping camera smooth
-- **GPU Acceleration**: Uses TensorFlow Lite GPU delegate when available
-- **NNAPI Support**: Falls back to NNAPI for hardware acceleration on older devices
-- **YUV Direct Processing**: No Bitmap conversion - works directly with camera frame data
-- **Reusable Buffers**: Allocates buffers once, reuses for each frame
-- **Single-Frame Processing**: Only processes one frame at a time to prevent queue overflow
-
-### Benchmark
-
-| Metric | Value |
-|--------|-------|
-| Processing Time | ~50-100ms per frame |
-| Memory Usage | <30 MB (runtime) |
-| Package Size | 20.92 MB |
-| Support | Android 21+ |
-
-## Architecture
-
-```
-VisionCamera (30fps callback)
-        ↓
-faceAntiSpoofFrameProcessor()
-        ↓
-Submit to background executor
-        ↓
-Non-blocking return
-        ↓
-Latest result available
-```
-
-Processing happens on:
-- Single-threaded `Executors.newSingleThreadExecutor()`
-- Daemon thread for proper lifecycle
-- Non-blocking callback returns immediately
-
-## Configuration
-
-### Accelerator Types
-
-The module automatically selects the best available accelerator:
-
-1. **GPU** - TensorFlow Lite GPU delegate (fastest)
-2. **NNAPI** - Android Neural Networks API
-3. **CPU** - Fallback for older devices
-
-Check which accelerator is in use:
-
-```javascript
-import FaceAntiSpoof from 'react-native-vision-camera-spoof-detector';
-
-FaceAntiSpoof.checkModelStatus()
-  .then(status => console.log('Accelerator:', status.accelerator));
-```
-
-## Troubleshooting
-
-### Module Not Available
-
-```javascript
-if (!isFaceAntiSpoofAvailable()) {
-  console.error('Face anti-spoof not available on this device');
-}
-```
-
-### Initialization Fails
-
-```javascript
-try {
-  await initializeFaceAntiSpoof();
-} catch (error) {
-  console.error('Init error:', error.message);
-}
-```
-
-### Frame Processing Too Slow
-
-- Ensure you're using a physical device (emulators are slow)
-- Check if GPU acceleration is working
-- Reduce frame processor workload
-- Consider skipping some frames
-
-## License
-
-MIT © JESCON TECHNOLOGIES PVT LTD
-
-## Support
-
-For issues and feature requests, visit: [GitHub Issues](https://github.com/jescon-tech/react-native-vision-camera-spoof-detector/issues)
-
-## Changelog
-
-See [CHANGELOG.md](./CHANGELOG.md) for version history and updates.
-
----
-
-**Package Version:** 1.0.0  
-**Last Updated:** November 18, 2025
+# react-native-vision-camera-spoof-detector
+
+High-performance face anti-spoofing and liveness detection module for React Native Vision Camera. Uses TensorFlow Lite with GPU acceleration and optimized YUV processing.
+
+## Features
+
+- **High Accuracy**: Utilizes advanced TensorFlow Lite models for reliable spoof detection.
+- **Real-time Performance**: GPU-accelerated processing ensures smooth frame rates.
+- **Easy Integration**: Seamlessly integrates with `react-native-vision-camera`.
+- **YUV Processing**: Optimized for efficient image data handling.
+
+## Installation
+
+```bash
+npm install react-native-vision-camera-spoof-detector
+# or
+yarn add react-native-vision-camera-spoof-detector
+```
+
+Make sure you have `react-native-vision-camera` installed:
+
+```bash
+npm install react-native-vision-camera
+# or
+yarn add react-native-vision-camera
+```
+
+## Usage
+
+Here's a basic example of how to use the spoof detector with Vision Camera:
+
+```javascript
+import React, { useEffect, useState } from 'react';
+import { StyleSheet, Text, View } from 'react-native';
+import { Camera, useCameraDevices, useFrameProcessor } from 'react-native-vision-camera';
+import { faceAntiSpoofFrameProcessor, initializeFaceAntiSpoof } from 'react-native-vision-camera-spoof-detector';
+import { runOnJS } from 'react-native-reanimated';
+
+export default function App() {
+  const devices = useCameraDevices();
+  const device = devices.front;
+  const [spoofResult, setSpoofResult] = useState(null);
+
+  useEffect(() => {
+    // Initialize the module
+    initializeFaceAntiSpoof().then((success) => {
+      console.log('FaceAntiSpoof initialized:', success);
+    });
+  }, []);
+
+  const frameProcessor = useFrameProcessor((frame) => {
+    'worklet';
+    const result = faceAntiSpoofFrameProcessor(frame);
+    if (result) {
+        runOnJS(setSpoofResult)(result);
+    }
+  }, []);
+
+  if (device == null) return <Text>Loading...</Text>;
+
+  return (
+    <View style={styles.container}>
+      <Camera
+        style={StyleSheet.absoluteFill}
+        device={device}
+        isActive={true}
+        frameProcessor={frameProcessor}
+        frameProcessorFps={5} // Adjust FPS as needed
+      />
+      {spoofResult && (
+        <View style={styles.resultContainer}>
+          <Text style={styles.resultText}>
+            Is Live: {spoofResult.isLive ? 'Yes' : 'No'}
+          </Text>
+          <Text style={styles.resultText}>
+            Score: {spoofResult.neuralNetworkScore?.toFixed(2)}
+          </Text>
+          <Text style={styles.resultText}>
+             Label: {spoofResult.label}
+          </Text>
+        </View>
+      )}
+    </View>
+  );
+}
+
+const styles = StyleSheet.create({
+  container: {
+    flex: 1,
+  },
+  resultContainer: {
+    position: 'absolute',
+    bottom: 50,
+    left: 0,
+    right: 0,
+    alignItems: 'center',
+    backgroundColor: 'rgba(0,0,0,0.5)',
+    padding: 10,
+  },
+  resultText: {
+    color: 'white',
+    fontSize: 20,
+    fontWeight: 'bold',
+  },
+});
+```
+
+## API
+
+### `initializeFaceAntiSpoof()`
+
+Initializes the face anti-spoofing module. Must be called before using the frame processor.
+
+- **Returns**: `Promise<boolean>` - `true` if initialization was successful.
+
+### `faceAntiSpoofFrameProcessor(frame)`
+
+Processes the camera frame and returns the spoof detection result.
+
+- **frame**: The frame object from `react-native-vision-camera`.
+- **Returns**: `FaceAntiSpoofingResult | null`
+
+#### `FaceAntiSpoofingResult`
+
+- `isLive` (boolean): `true` if the face is real (live), `false` otherwise.
+- `label` (string): "Live Face" or "Spoof Face".
+- `neuralNetworkScore` (number): Confidence score (0.0 to 1.0).
+- `laplacianScore` (number): Image quality score based on Laplacian variance.
+- `combinedScore` (number): Weighted average score.
+- `error` (string, optional): Error message if detection failed.
+
+## Contributing
+
+See the [contributing guide](CONTRIBUTING.md) to learn how to contribute to the repository and the development workflow.
+
+## License
+
+JESCON TECHNOLOGIES PVT LTD

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

@@ -146,11 +146,10 @@ class FaceAntiSpoofFrameProcessor : FrameProcessorPlugin() {
                 val result = faceAntispoof.advancedAntiSpoofing(nv21, width, height)
 
                 val resultMap = mapOf(
-                    "isLive" to result.isLive,
-                    "label" to result.label,
                     "neuralNetworkScore" to result.neuralNetworkScore.toDouble(),
                     "laplacianScore" to result.laplacianScore,
-                    "combinedScore" to result.combinedScore.toDouble()
+                    "combinedScore" to result.combinedScore.toDouble(),
+                    "confidence" to result.confidence.toDouble()
                 )
                 
                 // Update the latest result for the next callback