react-native-vision-camera-spoof-detector 1.0.0

package/CHANGELOG.md

@@ -0,0 +1,48 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [1.0.0] - 2025-11-18
+
+### Added
+- Multi-threading support with `Executors.newSingleThreadExecutor()`
+- Proper npm package structure with reduced bundle size
+- TypeScript type definitions (`index.d.ts`)
+- `.npmignore` and `.gitignore` files for proper package management
+- Support for GPU acceleration via TensorFlow Lite GPU delegate
+- Support for NNAPI acceleration as fallback
+- Daemon thread configuration for proper app lifecycle management
+- Comprehensive error handling and logging
+
+### Changed
+- Updated package.json with proper metadata and peer dependencies
+- Improved module initialization and cleanup procedures
+- Enhanced frame processor to prevent blocking VisionCamera callback thread
+- Optimized YUV to RGB conversion with reusable buffers
+- Increased version from 0.0.26 to 1.0.0 for stable release
+
+### Fixed
+- Frame drops caused by blocking processing in callback thread
+- Memory leaks by implementing proper resource cleanup
+- Executor thread lifecycle management
+
+### Removed
+- Build artifacts from `.cxx/` directory (49.44 MB)
+- Build output from `build/` directory (56.99 MB)
+- Unnecessary Gradle wrapper binaries
+
+### Performance Improvements
+- Reduced package size from 127.35 MB to 20.92 MB (83.6% reduction)
+- Non-blocking callback returns immediately
+- Single-frame processing prevents queue overflow
+- Optimized memory usage with daemon threads
+
+## [0.0.26] - Previous
+
+### Initial Release
+- Basic face anti-spoofing detection
+- React Native Vision Camera integration
+- TensorFlow Lite model support

package/README.md

@@ -0,0 +1,220 @@
+# 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