@arfuhad/react-native-smart-camera 0.1.1 → 0.1.5

package/build/webrtc/types.js

@@ -1,5 +1,38 @@
 /**
  * WebRTC-related types for the SmartCamera module
  */
-export {};
+// =============================================================================
+// Default Configurations
+// =============================================================================
+/**
+ * Default ICE servers (Google STUN servers)
+ */
+export const DEFAULT_ICE_SERVERS = [
+    { urls: 'stun:stun.l.google.com:19302' },
+    { urls: 'stun:stun1.l.google.com:19302' },
+];
+/**
+ * Default peer connection configuration
+ */
+export const DEFAULT_PEER_CONNECTION_CONFIG = {
+    iceServers: DEFAULT_ICE_SERVERS,
+    iceTransportPolicy: 'all',
+    bundlePolicy: 'balanced',
+};
+/**
+ * Default media constraints
+ */
+export const DEFAULT_MEDIA_CONSTRAINTS = {
+    video: {
+        width: { ideal: 1280 },
+        height: { ideal: 720 },
+        frameRate: { ideal: 30 },
+        facingMode: 'user',
+    },
+    audio: {
+        echoCancellation: true,
+        noiseSuppression: true,
+        autoGainControl: true,
+    },
+};
 //# sourceMappingURL=types.js.map

package/build/webrtc/types.js.map

@@ -1 +1 @@
-{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/webrtc/types.ts"],"names":[],"mappings":"AAAA;;GAEG","sourcesContent":["/**\n * WebRTC-related types for the SmartCamera module\n */\n\n/**\n * Video frame format for WebRTC\n */\nexport type VideoFrameFormat = 'I420' | 'NV12' | 'NV21' | 'BGRA';\n\n/**\n * Configuration for the WebRTC video source\n */\nexport interface WebRTCVideoSourceConfig {\n  /** Frame width in pixels */\n  width: number;\n  \n  /** Frame height in pixels */\n  height: number;\n  \n  /** Target frame rate */\n  frameRate: number;\n  \n  /** Video frame format. Default: 'I420' */\n  format?: VideoFrameFormat;\n}\n\n/**\n * WebRTC connection state\n */\nexport type WebRTCConnectionState =\n  | 'new'\n  | 'connecting'\n  | 'connected'\n  | 'disconnected'\n  | 'failed'\n  | 'closed';\n\n/**\n * WebRTC stream statistics\n */\nexport interface WebRTCStreamStats {\n  /** Current frame rate */\n  frameRate: number;\n  \n  /** Frames sent */\n  framesSent: number;\n  \n  /** Frames dropped */\n  framesDropped: number;\n  \n  /** Bytes sent */\n  bytesSent: number;\n  \n  /** Current bitrate in bps */\n  bitrate: number;\n  \n  /** Round-trip time in ms */\n  rtt?: number;\n}\n\n/**\n * WebRTC stream quality settings\n */\nexport interface WebRTCQualitySettings {\n  /** Maximum bitrate in bps */\n  maxBitrate?: number;\n  \n  /** Minimum bitrate in bps */\n  minBitrate?: number;\n  \n  /** Target frame rate */\n  targetFrameRate?: number;\n  \n  /** Resolution scale (0.0 - 1.0) */\n  resolutionScale?: number;\n}\n\n/**\n * Event emitted when WebRTC stream state changes\n */\nexport interface WebRTCStreamEvent {\n  type: 'started' | 'stopped' | 'error' | 'stats';\n  timestamp: number;\n  error?: Error;\n  stats?: WebRTCStreamStats;\n}\n\n"]}
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/webrtc/types.ts"],"names":[],"mappings":"AAAA;;GAEG;AAkUH,gFAAgF;AAChF,yBAAyB;AACzB,gFAAgF;AAEhF;;GAEG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAgB;IAC9C,EAAE,IAAI,EAAE,8BAA8B,EAAE;IACxC,EAAE,IAAI,EAAE,+BAA+B,EAAE;CAC1C,CAAC;AAEF;;GAEG;AACH,MAAM,CAAC,MAAM,8BAA8B,GAAyB;IAClE,UAAU,EAAE,mBAAmB;IAC/B,kBAAkB,EAAE,KAAK;IACzB,YAAY,EAAE,UAAU;CACzB,CAAC;AAEF;;GAEG;AACH,MAAM,CAAC,MAAM,yBAAyB,GAAqB;IACzD,KAAK,EAAE;QACL,KAAK,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE;QACtB,MAAM,EAAE,EAAE,KAAK,EAAE,GAAG,EAAE;QACtB,SAAS,EAAE,EAAE,KAAK,EAAE,EAAE,EAAE;QACxB,UAAU,EAAE,MAAM;KACnB;IACD,KAAK,EAAE;QACL,gBAAgB,EAAE,IAAI;QACtB,gBAAgB,EAAE,IAAI;QACtB,eAAe,EAAE,IAAI;KACtB;CACF,CAAC"}

package/ios/FaceDetectorFrameProcessorPlugin.m

@@ -0,0 +1,11 @@
+#import <VisionCamera/FrameProcessorPlugin.h>
+#import <VisionCamera/FrameProcessorPluginRegistry.h>
+
+#if __has_include("react_native_smart_camera-Swift.h")
+#import "react_native_smart_camera-Swift.h"
+#else
+#import <react_native_smart_camera/react_native_smart_camera-Swift.h>
+#endif
+
+// Register the frame processor plugin
+VISION_EXPORT_FRAME_PROCESSOR(FaceDetectorFrameProcessorPlugin, detectFaces)

package/ios/FaceDetectorFrameProcessorPlugin.swift

@@ -0,0 +1,304 @@
+import Foundation
+import VisionCamera
+import MLKitFaceDetection
+import MLKitVision
+
+@objc(FaceDetectorFrameProcessorPlugin)
+public class FaceDetectorFrameProcessorPlugin: FrameProcessorPlugin {
+    
+    private var faceDetector: FaceDetector?
+    private var currentOptions: FaceDetectorOptions?
+    
+    // Auto mode options (stored separately as they don't affect detector)
+    private var autoMode: Bool = false
+    private var windowWidth: CGFloat = 1.0
+    private var windowHeight: CGFloat = 1.0
+    private var cameraFacing: String = "front"
+    
+    public override init(proxy: VisionCameraProxyHolder, options: [AnyHashable: Any]! = [:]) {
+        super.init(proxy: proxy, options: options)
+        print("[FaceDetectorPlugin] Initialized")
+        updateDetectorOptions(options as? [String: Any] ?? [:])
+    }
+    
+    private func updateDetectorOptions(_ options: [String: Any]) {
+        let performanceMode = options["performanceMode"] as? String ?? "fast"
+        let landmarkMode = options["landmarkMode"] as? String ?? "none"
+        let contourMode = options["contourMode"] as? String ?? "none"
+        let classificationMode = options["classificationMode"] as? String ?? "none"
+        let minFaceSize = options["minFaceSize"] as? CGFloat ?? 0.15
+        let trackingEnabled = options["trackingEnabled"] as? Bool ?? false
+        
+        // Update auto mode options
+        autoMode = options["autoMode"] as? Bool ?? false
+        windowWidth = options["windowWidth"] as? CGFloat ?? 1.0
+        windowHeight = options["windowHeight"] as? CGFloat ?? 1.0
+        cameraFacing = options["cameraFacing"] as? String ?? "front"
+        
+        let newOptions = FaceDetectorOptions()
+        
+        switch performanceMode {
+        case "accurate":
+            newOptions.performanceMode = .accurate
+        default:
+            newOptions.performanceMode = .fast
+        }
+        
+        switch landmarkMode {
+        case "all":
+            newOptions.landmarkMode = .all
+        default:
+            newOptions.landmarkMode = .none
+        }
+        
+        switch contourMode {
+        case "all":
+            newOptions.contourMode = .all
+        default:
+            newOptions.contourMode = .none
+        }
+        
+        switch classificationMode {
+        case "all":
+            newOptions.classificationMode = .all
+        default:
+            newOptions.classificationMode = .none
+        }
+        
+        newOptions.minFaceSize = minFaceSize
+        newOptions.isTrackingEnabled = trackingEnabled
+        
+        faceDetector = FaceDetector.faceDetector(options: newOptions)
+        currentOptions = newOptions
+        print("[FaceDetectorPlugin] Detector updated with new options")
+    }
+    
+    public override func callback(_ frame: Frame, withArguments arguments: [AnyHashable: Any]?) -> Any? {
+        if let args = arguments as? [String: Any], !args.isEmpty {
+            updateDetectorOptions(args)
+        }
+        
+        guard let detector = faceDetector else {
+            print("[FaceDetectorPlugin] Detector not initialized")
+            return []
+        }
+        
+        guard let pixelBuffer = CMSampleBufferGetImageBuffer(frame.buffer) else {
+            print("[FaceDetectorPlugin] Could not get pixel buffer")
+            return []
+        }
+        
+        let image = VisionImage(buffer: frame.buffer)
+        image.orientation = getImageOrientation(frame.orientation)
+        
+        let frameWidth = CVPixelBufferGetWidth(pixelBuffer)
+        let frameHeight = CVPixelBufferGetHeight(pixelBuffer)
+        
+        var detectedFaces: [Face] = []
+        let semaphore = DispatchSemaphore(value: 0)
+        
+        detector.process(image) { faces, error in
+            if let error = error {
+                print("[FaceDetectorPlugin] Detection error: \(error.localizedDescription)")
+            } else if let faces = faces {
+                detectedFaces = faces
+            }
+            semaphore.signal()
+        }
+        
+        _ = semaphore.wait(timeout: .now() + 0.1)
+        
+        return detectedFaces.map { face in
+            faceToDict(
+                face, 
+                frameWidth: frameWidth, 
+                frameHeight: frameHeight,
+                autoMode: autoMode,
+                windowWidth: windowWidth,
+                windowHeight: windowHeight,
+                cameraFacing: cameraFacing
+            )
+        }
+    }
+    
+    private func getImageOrientation(_ orientation: Orientation) -> UIImage.Orientation {
+        switch orientation {
+        case .portrait:
+            return .right
+        case .portraitUpsideDown:
+            return .left
+        case .landscapeLeft:
+            return .up
+        case .landscapeRight:
+            return .down
+        @unknown default:
+            return .right
+        }
+    }
+    
+    private func faceToDict(
+        _ face: Face, 
+        frameWidth: Int, 
+        frameHeight: Int,
+        autoMode: Bool,
+        windowWidth: CGFloat,
+        windowHeight: CGFloat,
+        cameraFacing: String
+    ) -> [String: Any] {
+        var result: [String: Any] = [:]
+        
+        // Calculate scale factors for autoMode
+        let scaleX = autoMode ? windowWidth / CGFloat(frameWidth) : 1.0 / CGFloat(frameWidth)
+        let scaleY = autoMode ? windowHeight / CGFloat(frameHeight) : 1.0 / CGFloat(frameHeight)
+        let mirrorX = autoMode && cameraFacing == "front"
+        
+        // Bounding box
+        let bounds = face.frame
+        let x: CGFloat
+        if mirrorX {
+            x = windowWidth - ((bounds.origin.x + bounds.width) * scaleX)
+        } else {
+            x = bounds.origin.x * scaleX
+        }
+        
+        result["bounds"] = [
+            "x": x,
+            "y": bounds.origin.y * scaleY,
+            "width": bounds.width * scaleX,
+            "height": bounds.height * scaleY
+        ]
+        
+        // Angles
+        result["rollAngle"] = face.headEulerAngleZ
+        result["pitchAngle"] = face.headEulerAngleX
+        result["yawAngle"] = face.headEulerAngleY
+        
+        // Classification probabilities
+        if face.hasSmilingProbability {
+            result["smilingProbability"] = face.smilingProbability
+        }
+        if face.hasLeftEyeOpenProbability {
+            result["leftEyeOpenProbability"] = face.leftEyeOpenProbability
+        }
+        if face.hasRightEyeOpenProbability {
+            result["rightEyeOpenProbability"] = face.rightEyeOpenProbability
+        }
+        
+        // Tracking ID
+        if face.hasTrackingID {
+            result["trackingId"] = face.trackingID
+        }
+        
+        // Landmarks
+        var landmarks: [String: Any] = [:]
+        
+        if let leftEye = face.landmark(ofType: .leftEye) {
+            landmarks["leftEye"] = pointToDict(leftEye.position, scaleX: scaleX, scaleY: scaleY, mirrorX: mirrorX, windowWidth: windowWidth)
+        }
+        if let rightEye = face.landmark(ofType: .rightEye) {
+            landmarks["rightEye"] = pointToDict(rightEye.position, scaleX: scaleX, scaleY: scaleY, mirrorX: mirrorX, windowWidth: windowWidth)
+        }
+        if let noseBase = face.landmark(ofType: .noseBase) {
+            landmarks["noseBase"] = pointToDict(noseBase.position, scaleX: scaleX, scaleY: scaleY, mirrorX: mirrorX, windowWidth: windowWidth)
+        }
+        if let leftCheek = face.landmark(ofType: .leftCheek) {
+            landmarks["leftCheek"] = pointToDict(leftCheek.position, scaleX: scaleX, scaleY: scaleY, mirrorX: mirrorX, windowWidth: windowWidth)
+        }
+        if let rightCheek = face.landmark(ofType: .rightCheek) {
+            landmarks["rightCheek"] = pointToDict(rightCheek.position, scaleX: scaleX, scaleY: scaleY, mirrorX: mirrorX, windowWidth: windowWidth)
+        }
+        if let mouthLeft = face.landmark(ofType: .mouthLeft) {
+            landmarks["mouthLeft"] = pointToDict(mouthLeft.position, scaleX: scaleX, scaleY: scaleY, mirrorX: mirrorX, windowWidth: windowWidth)
+        }
+        if let mouthRight = face.landmark(ofType: .mouthRight) {
+            landmarks["mouthRight"] = pointToDict(mouthRight.position, scaleX: scaleX, scaleY: scaleY, mirrorX: mirrorX, windowWidth: windowWidth)
+        }
+        if let mouthBottom = face.landmark(ofType: .mouthBottom) {
+            landmarks["mouthBottom"] = pointToDict(mouthBottom.position, scaleX: scaleX, scaleY: scaleY, mirrorX: mirrorX, windowWidth: windowWidth)
+        }
+        if let leftEar = face.landmark(ofType: .leftEar) {
+            landmarks["leftEar"] = pointToDict(leftEar.position, scaleX: scaleX, scaleY: scaleY, mirrorX: mirrorX, windowWidth: windowWidth)
+        }
+        if let rightEar = face.landmark(ofType: .rightEar) {
+            landmarks["rightEar"] = pointToDict(rightEar.position, scaleX: scaleX, scaleY: scaleY, mirrorX: mirrorX, windowWidth: windowWidth)
+        }
+        
+        if !landmarks.isEmpty {
+            result["landmarks"] = landmarks
+        }
+        
+        // All contours (like reference package)
+        var contours: [String: Any] = [:]
+        
+        if let contour = face.contour(ofType: .face) {
+            contours["face"] = contour.points.map { pointToDict($0, scaleX: scaleX, scaleY: scaleY, mirrorX: mirrorX, windowWidth: windowWidth) }
+        }
+        if let contour = face.contour(ofType: .leftEyebrowTop) {
+            contours["leftEyebrowTop"] = contour.points.map { pointToDict($0, scaleX: scaleX, scaleY: scaleY, mirrorX: mirrorX, windowWidth: windowWidth) }
+        }
+        if let contour = face.contour(ofType: .leftEyebrowBottom) {
+            contours["leftEyebrowBottom"] = contour.points.map { pointToDict($0, scaleX: scaleX, scaleY: scaleY, mirrorX: mirrorX, windowWidth: windowWidth) }
+        }
+        if let contour = face.contour(ofType: .rightEyebrowTop) {
+            contours["rightEyebrowTop"] = contour.points.map { pointToDict($0, scaleX: scaleX, scaleY: scaleY, mirrorX: mirrorX, windowWidth: windowWidth) }
+        }
+        if let contour = face.contour(ofType: .rightEyebrowBottom) {
+            contours["rightEyebrowBottom"] = contour.points.map { pointToDict($0, scaleX: scaleX, scaleY: scaleY, mirrorX: mirrorX, windowWidth: windowWidth) }
+        }
+        if let contour = face.contour(ofType: .leftEye) {
+            contours["leftEye"] = contour.points.map { pointToDict($0, scaleX: scaleX, scaleY: scaleY, mirrorX: mirrorX, windowWidth: windowWidth) }
+        }
+        if let contour = face.contour(ofType: .rightEye) {
+            contours["rightEye"] = contour.points.map { pointToDict($0, scaleX: scaleX, scaleY: scaleY, mirrorX: mirrorX, windowWidth: windowWidth) }
+        }
+        if let contour = face.contour(ofType: .upperLipTop) {
+            contours["upperLipTop"] = contour.points.map { pointToDict($0, scaleX: scaleX, scaleY: scaleY, mirrorX: mirrorX, windowWidth: windowWidth) }
+        }
+        if let contour = face.contour(ofType: .upperLipBottom) {
+            contours["upperLipBottom"] = contour.points.map { pointToDict($0, scaleX: scaleX, scaleY: scaleY, mirrorX: mirrorX, windowWidth: windowWidth) }
+        }
+        if let contour = face.contour(ofType: .lowerLipTop) {
+            contours["lowerLipTop"] = contour.points.map { pointToDict($0, scaleX: scaleX, scaleY: scaleY, mirrorX: mirrorX, windowWidth: windowWidth) }
+        }
+        if let contour = face.contour(ofType: .lowerLipBottom) {
+            contours["lowerLipBottom"] = contour.points.map { pointToDict($0, scaleX: scaleX, scaleY: scaleY, mirrorX: mirrorX, windowWidth: windowWidth) }
+        }
+        if let contour = face.contour(ofType: .noseBridge) {
+            contours["noseBridge"] = contour.points.map { pointToDict($0, scaleX: scaleX, scaleY: scaleY, mirrorX: mirrorX, windowWidth: windowWidth) }
+        }
+        if let contour = face.contour(ofType: .noseBottom) {
+            contours["noseBottom"] = contour.points.map { pointToDict($0, scaleX: scaleX, scaleY: scaleY, mirrorX: mirrorX, windowWidth: windowWidth) }
+        }
+        if let contour = face.contour(ofType: .leftCheek) {
+            contours["leftCheek"] = contour.points.map { pointToDict($0, scaleX: scaleX, scaleY: scaleY, mirrorX: mirrorX, windowWidth: windowWidth) }
+        }
+        if let contour = face.contour(ofType: .rightCheek) {
+            contours["rightCheek"] = contour.points.map { pointToDict($0, scaleX: scaleX, scaleY: scaleY, mirrorX: mirrorX, windowWidth: windowWidth) }
+        }
+        
+        if !contours.isEmpty {
+            result["contours"] = contours
+        }
+        
+        return result
+    }
+    
+    private func pointToDict(
+        _ point: VisionPoint, 
+        scaleX: CGFloat, 
+        scaleY: CGFloat,
+        mirrorX: Bool,
+        windowWidth: CGFloat
+    ) -> [String: CGFloat] {
+        let x: CGFloat
+        if mirrorX {
+            x = windowWidth - (point.x * scaleX)
+        } else {
+            x = point.x * scaleX
+        }
+        return [
+            "x": x,
+            "y": point.y * scaleY
+        ]
+    }
+}

package/package.json

@@ -1,18 +1,18 @@
 {
   "name": "@arfuhad/react-native-smart-camera",
-  "version": "0.1.1",
-  "description": "Expo-compatible native module for camera preview, face detection, blink detection, and WebRTC streaming",
+  "version": "0.1.5",
+  "description": "VisionCamera frame processor plugin for face detection, blink detection, and WebRTC streaming",
   "main": "build/index.js",
   "types": "build/index.d.ts",
+  "react-native": "src/index.ts",
+  "source": "src/index.ts",
   "scripts": {
-    "build": "expo-module build",
+    "build": "tsc --project tsconfig.build.json",
     "build:plugin": "tsc --project plugin/tsconfig.json",
-    "clean": "expo-module clean && rm -rf plugin/build",
-    "lint": "expo-module lint",
-    "test": "expo-module test",
-    "prepare": "expo-module prepare && npm run build:plugin",
-    "prepublishOnly": "expo-module prepublishOnly",
-    "expo-module": "expo-module"
+    "clean": "rm -rf build plugin/build",
+    "lint": "eslint src --ext .ts,.tsx",
+    "prepare": "npm run build && npm run build:plugin",
+    "prepublishOnly": "npm run clean && npm run build"
   },
   "keywords": [
     "react-native",
@@ -23,18 +23,19 @@
     "webrtc",
     "vision-camera",
     "ml-kit",
-    "expo-module",
     "frame-processor"
   ],
   "files": [
+    "src",
     "build",
     "ios",
     "android",
     "plugin/build",
     "app.plugin.js",
-    "expo-module.config.json",
+    "react-native-smart-camera.podspec",
     "README.md",
-    "ARCHITECTURE.md"
+    "ARCHITECTURE.md",
+    "CHANGELOG.md"
   ],
   "repository": {
     "type": "git",

package/react-native-smart-camera.podspec

@@ -0,0 +1,32 @@
+require 'json'
+
+package = JSON.parse(File.read(File.join(__dir__, 'package.json')))
+
+Pod::Spec.new do |s|
+  s.name           = 'react-native-smart-camera'
+  s.version        = package['version']
+  s.summary        = package['description']
+  s.description    = package['description']
+  s.license        = package['license']
+  s.author         = package['author']
+  s.homepage       = package['homepage']
+  s.platforms      = { :ios => '13.4' }
+  s.swift_version  = '5.4'
+  s.source         = { git: package['repository']['url'], tag: "v#{s.version}" }
+  s.static_framework = true
+
+  s.source_files = "ios/**/*.{h,m,mm,swift}"
+  
+  # React Native dependency
+  s.dependency 'React-Core'
+  
+  # VisionCamera for frame processor API
+  s.dependency 'VisionCamera'
+  
+  # Google ML Kit Face Detection
+  s.dependency 'GoogleMLKit/FaceDetection', '~> 5.0.0'
+
+  # Exclude test files
+  s.exclude_files = "ios/Tests/**/*"
+end
+

package/src/detection/blinkProcessor.ts

@@ -0,0 +1,127 @@
+import type { Face, BlinkEvent } from '../types';
+
+/**
+ * Threshold for considering an eye as closed
+ */
+const EYE_CLOSED_THRESHOLD = 0.4;
+
+/**
+ * Threshold for considering an eye as open
+ */
+const EYE_OPEN_THRESHOLD = 0.6;
+
+/**
+ * State for tracking blink across frames
+ */
+interface BlinkState {
+  wasEyesClosed: boolean;
+  lastBlinkTimestamp: number;
+}
+
+// Global blink state per face tracking ID
+const blinkStates = new Map<number, BlinkState>();
+
+/**
+ * Process faces to detect blinks
+ * 
+ * @param faces - Array of detected faces
+ * @param lastBlinkTimestamp - Timestamp of the last detected blink
+ * @param debounceMs - Minimum time between blinks in milliseconds
+ * @returns BlinkEvent if a blink was detected, null otherwise
+ */
+export function processBlinkFromFaces(
+  faces: Face[],
+  lastBlinkTimestamp: number,
+  debounceMs: number = 300
+): BlinkEvent | null {
+  'worklet';
+
+  if (faces.length === 0) {
+    return null;
+  }
+
+  // Use the first face (most prominent)
+  const face = faces[0];
+
+  // Ensure we have eye classification data
+  if (
+    face.leftEyeOpenProbability === undefined ||
+    face.rightEyeOpenProbability === undefined
+  ) {
+    return null;
+  }
+
+  const leftEyeOpen = face.leftEyeOpenProbability;
+  const rightEyeOpen = face.rightEyeOpenProbability;
+  const now = Date.now();
+
+  // Get or create blink state for this face
+  const faceId = face.trackingId ?? 0;
+  let state = blinkStates.get(faceId);
+
+  if (!state) {
+    state = {
+      wasEyesClosed: false,
+      lastBlinkTimestamp: 0,
+    };
+    blinkStates.set(faceId, state);
+  }
+
+  // Check if eyes are currently closed
+  const eyesClosed = leftEyeOpen < EYE_CLOSED_THRESHOLD && rightEyeOpen < EYE_CLOSED_THRESHOLD;
+
+  // Check if eyes are currently open
+  const eyesOpen = leftEyeOpen > EYE_OPEN_THRESHOLD && rightEyeOpen > EYE_OPEN_THRESHOLD;
+
+  // Detect blink: transition from closed to open
+  const isBlink = state.wasEyesClosed && eyesOpen && (now - state.lastBlinkTimestamp) > debounceMs;
+
+  // Update state
+  if (eyesClosed) {
+    state.wasEyesClosed = true;
+  } else if (eyesOpen) {
+    state.wasEyesClosed = false;
+  }
+
+  if (isBlink) {
+    state.lastBlinkTimestamp = now;
+
+    return {
+      timestamp: now,
+      leftEyeOpen,
+      rightEyeOpen,
+      isBlink: true,
+      faceId: face.trackingId,
+    };
+  }
+
+  return null;
+}
+
+/**
+ * Reset blink state for all faces
+ */
+export function resetBlinkStates(): void {
+  blinkStates.clear();
+}
+
+/**
+ * Get current eye state without blink detection
+ * Useful for real-time eye tracking UI
+ */
+export function getEyeState(face: Face): { leftOpen: number; rightOpen: number } | null {
+  'worklet';
+
+  if (
+    face.leftEyeOpenProbability === undefined ||
+    face.rightEyeOpenProbability === undefined
+  ) {
+    return null;
+  }
+
+  return {
+    leftOpen: face.leftEyeOpenProbability,
+    rightOpen: face.rightEyeOpenProbability,
+  };
+}
+

package/src/detection/faceDetector.ts

@@ -0,0 +1,78 @@
+import { VisionCameraProxy, type Frame } from 'react-native-vision-camera';
+import type { Face, FrameProcessorOptions } from '../types';
+
+/**
+ * Initialize the face detector frame processor plugin
+ * This registers the native plugin with VisionCamera
+ */
+const plugin = VisionCameraProxy.initFrameProcessorPlugin('detectFaces', {});
+
+/**
+ * Default face detection options
+ */
+const DEFAULT_OPTIONS: FrameProcessorOptions = {
+  performanceMode: 'fast',
+  landmarkMode: 'none',
+  contourMode: 'none',
+  classificationMode: 'none',
+  minFaceSize: 0.15,
+  trackingEnabled: false,
+  cameraFacing: 'front',
+  autoMode: false,
+  windowWidth: 1.0,
+  windowHeight: 1.0,
+};
+
+/**
+ * Detect faces in a camera frame
+ * 
+ * @param frame - The camera frame from VisionCamera
+ * @param options - Face detection options
+ * @returns Array of detected faces
+ */
+export function detectFaces(frame: Frame, options?: Partial<FrameProcessorOptions>): Face[] {
+  'worklet';
+
+  if (plugin == null) {
+    // Plugin not available - return empty array
+    // This can happen if the native module is not properly linked
+    return [];
+  }
+
+  const mergedOptions: FrameProcessorOptions = {
+    ...DEFAULT_OPTIONS,
+    ...options,
+  };
+
+  try {
+    // Convert options to a format compatible with VisionCamera plugin API
+    const pluginOptions: Record<string, string | number | boolean | undefined> = {
+      performanceMode: mergedOptions.performanceMode,
+      landmarkMode: mergedOptions.landmarkMode,
+      contourMode: mergedOptions.contourMode,
+      classificationMode: mergedOptions.classificationMode,
+      minFaceSize: mergedOptions.minFaceSize,
+      trackingEnabled: mergedOptions.trackingEnabled,
+      cameraFacing: mergedOptions.cameraFacing,
+      autoMode: mergedOptions.autoMode,
+      windowWidth: mergedOptions.windowWidth,
+      windowHeight: mergedOptions.windowHeight,
+    };
+    
+    const result = plugin.call(frame, pluginOptions) as Face[] | null | undefined;
+    return result ?? [];
+  } catch (error) {
+    // Return empty array on error in worklet context
+    return [];
+  }
+}
+
+/**
+ * Check if the face detector plugin is available
+ * @returns true if the plugin is registered and available
+ */
+export function isFaceDetectorAvailable(): boolean {
+  return plugin != null;
+}
+
+

package/src/detection/index.ts

@@ -0,0 +1,3 @@
+export { detectFaces, isFaceDetectorAvailable } from './faceDetector';
+export { processBlinkFromFaces, resetBlinkStates, getEyeState } from './blinkProcessor';
+export { detectFacesInImage } from './staticImageDetector';