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

package/src/utils/index.ts

@@ -0,0 +1,355 @@
+/**
+ * SmartCamera utility functions
+ */
+
+// ============================================================================
+// FPS Limiter
+// ============================================================================
+
+/**
+ * Creates an FPS limiter for frame processing
+ * 
+ * @param targetFps - Target frames per second
+ * @returns Object with shouldProcess function
+ * 
+ * @example
+ * ```ts
+ * const limiter = createFpsLimiter(15);
+ * 
+ * const frameProcessor = useFrameProcessor((frame) => {
+ *   if (!limiter.shouldProcess()) return;
+ *   // Process frame...
+ * }, []);
+ * ```
+ */
+export function createFpsLimiter(targetFps: number) {
+  const frameInterval = 1000 / targetFps;
+  let lastFrameTime = 0;
+
+  return {
+    shouldProcess: (): boolean => {
+      const now = Date.now();
+      if (now - lastFrameTime >= frameInterval) {
+        lastFrameTime = now;
+        return true;
+      }
+      return false;
+    },
+    reset: () => {
+      lastFrameTime = 0;
+    },
+    setTargetFps: (fps: number) => {
+      // Note: This creates a new interval but doesn't update the closure
+      // Consider using a ref if dynamic FPS changes are needed
+    },
+  };
+}
+
+// ============================================================================
+// Debounce
+// ============================================================================
+
+/**
+ * Creates a debounced function
+ * 
+ * @param fn - Function to debounce
+ * @param delay - Delay in milliseconds
+ * @returns Debounced function
+ */
+export function debounce<T extends (...args: unknown[]) => unknown>(
+  fn: T,
+  delay: number
+): (...args: Parameters<T>) => void {
+  let timeoutId: ReturnType<typeof setTimeout> | null = null;
+
+  return (...args: Parameters<T>) => {
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+    }
+    timeoutId = setTimeout(() => {
+      fn(...args);
+      timeoutId = null;
+    }, delay);
+  };
+}
+
+// ============================================================================
+// Throttle
+// ============================================================================
+
+/**
+ * Creates a throttled function
+ * 
+ * @param fn - Function to throttle
+ * @param limit - Minimum time between calls in milliseconds
+ * @returns Throttled function
+ */
+export function throttle<T extends (...args: unknown[]) => unknown>(
+  fn: T,
+  limit: number
+): (...args: Parameters<T>) => void {
+  let lastCall = 0;
+
+  return (...args: Parameters<T>) => {
+    const now = Date.now();
+    if (now - lastCall >= limit) {
+      lastCall = now;
+      fn(...args);
+    }
+  };
+}
+
+// ============================================================================
+// Memory Pool for Face Objects
+// ============================================================================
+
+interface PooledObject<T> {
+  data: T;
+  inUse: boolean;
+}
+
+/**
+ * Creates an object pool for reducing garbage collection
+ * 
+ * @param factory - Factory function to create new objects
+ * @param initialSize - Initial pool size
+ * @param maxSize - Maximum pool size
+ */
+export function createObjectPool<T>(
+  factory: () => T,
+  initialSize: number = 10,
+  maxSize: number = 100
+) {
+  const pool: PooledObject<T>[] = [];
+
+  // Pre-populate pool
+  for (let i = 0; i < initialSize; i++) {
+    pool.push({ data: factory(), inUse: false });
+  }
+
+  return {
+    acquire: (): T => {
+      // Find an available object
+      const available = pool.find((obj) => !obj.inUse);
+      if (available) {
+        available.inUse = true;
+        return available.data;
+      }
+
+      // Create new if pool not at max
+      if (pool.length < maxSize) {
+        const newObj = { data: factory(), inUse: true };
+        pool.push(newObj);
+        return newObj.data;
+      }
+
+      // Pool exhausted, create temporary object
+      return factory();
+    },
+
+    release: (obj: T): void => {
+      const pooledObj = pool.find((p) => p.data === obj);
+      if (pooledObj) {
+        pooledObj.inUse = false;
+      }
+    },
+
+    clear: (): void => {
+      pool.length = 0;
+    },
+
+    getStats: () => ({
+      size: pool.length,
+      inUse: pool.filter((p) => p.inUse).length,
+      available: pool.filter((p) => !p.inUse).length,
+    }),
+  };
+}
+
+// ============================================================================
+// Error Utilities
+// ============================================================================
+
+import type { SmartCameraError, SmartCameraErrorCode } from '../types';
+
+/**
+ * Creates a SmartCameraError from an unknown error
+ * 
+ * @param error - The original error
+ * @param defaultCode - Default error code if not determinable
+ * @returns SmartCameraError
+ */
+export function createSmartCameraError(
+  error: unknown,
+  defaultCode: SmartCameraErrorCode = 'UNKNOWN_ERROR'
+): SmartCameraError {
+  if (error instanceof Error) {
+    // Check for specific error types
+    const message = error.message.toLowerCase();
+
+    let code: SmartCameraErrorCode = defaultCode;
+    if (message.includes('permission')) {
+      code = 'PERMISSION_DENIED';
+    } else if (message.includes('camera') && message.includes('unavailable')) {
+      code = 'CAMERA_UNAVAILABLE';
+    } else if (message.includes('webrtc')) {
+      code = 'WEBRTC_ERROR';
+    } else if (message.includes('mlkit') || message.includes('face detection')) {
+      code = 'ML_KIT_ERROR';
+    } else if (message.includes('frame processor')) {
+      code = 'FRAME_PROCESSOR_ERROR';
+    }
+
+    return {
+      code,
+      message: error.message,
+      nativeError: error,
+    };
+  }
+
+  return {
+    code: defaultCode,
+    message: String(error),
+  };
+}
+
+/**
+ * Safely execute a function and return a SmartCameraError on failure
+ */
+export async function safeExecute<T>(
+  fn: () => Promise<T>,
+  errorCode: SmartCameraErrorCode = 'UNKNOWN_ERROR'
+): Promise<{ data: T; error: null } | { data: null; error: SmartCameraError }> {
+  try {
+    const data = await fn();
+    return { data, error: null };
+  } catch (error) {
+    return { data: null, error: createSmartCameraError(error, errorCode) };
+  }
+}
+
+// ============================================================================
+// Validation Utilities
+// ============================================================================
+
+/**
+ * Validates face detection options
+ */
+export function validateFaceDetectionOptions(options: Record<string, unknown>): string[] {
+  const errors: string[] = [];
+
+  if (options.minFaceSize !== undefined) {
+    const minFaceSize = options.minFaceSize as number;
+    if (typeof minFaceSize !== 'number' || minFaceSize < 0 || minFaceSize > 1) {
+      errors.push('minFaceSize must be a number between 0 and 1');
+    }
+  }
+
+  if (options.performanceMode !== undefined) {
+    const mode = options.performanceMode as string;
+    if (mode !== 'fast' && mode !== 'accurate') {
+      errors.push('performanceMode must be "fast" or "accurate"');
+    }
+  }
+
+  if (options.landmarkMode !== undefined) {
+    const mode = options.landmarkMode as string;
+    if (mode !== 'none' && mode !== 'all') {
+      errors.push('landmarkMode must be "none" or "all"');
+    }
+  }
+
+  if (options.contourMode !== undefined) {
+    const mode = options.contourMode as string;
+    if (mode !== 'none' && mode !== 'all') {
+      errors.push('contourMode must be "none" or "all"');
+    }
+  }
+
+  if (options.classificationMode !== undefined) {
+    const mode = options.classificationMode as string;
+    if (mode !== 'none' && mode !== 'all') {
+      errors.push('classificationMode must be "none" or "all"');
+    }
+  }
+
+  // Warn about contourMode + trackingEnabled combination
+  if (options.contourMode === 'all' && options.trackingEnabled === true) {
+    errors.push(
+      'Warning: Using contourMode="all" with trackingEnabled=true is not recommended. ' +
+      'Contour detection only works on the most prominent face, making tracking less useful.'
+    );
+  }
+
+  return errors;
+}
+
+// ============================================================================
+// Performance Monitoring
+// ============================================================================
+
+interface PerformanceMetrics {
+  frameCount: number;
+  averageProcessingTime: number;
+  minProcessingTime: number;
+  maxProcessingTime: number;
+  droppedFrames: number;
+}
+
+/**
+ * Creates a performance monitor for frame processing
+ */
+export function createPerformanceMonitor(windowSize: number = 30) {
+  const processingTimes: number[] = [];
+  let frameCount = 0;
+  let droppedFrames = 0;
+  let lastFrameTime = 0;
+  const targetFrameTime = 1000 / 30; // 30 FPS target
+
+  return {
+    startFrame: (): number => {
+      return Date.now();
+    },
+
+    endFrame: (startTime: number): void => {
+      const processingTime = Date.now() - startTime;
+      processingTimes.push(processingTime);
+      
+      // Keep only last N samples
+      if (processingTimes.length > windowSize) {
+        processingTimes.shift();
+      }
+
+      frameCount++;
+
+      // Check for dropped frames
+      const now = Date.now();
+      if (lastFrameTime > 0) {
+        const frameGap = now - lastFrameTime;
+        if (frameGap > targetFrameTime * 2) {
+          droppedFrames += Math.floor(frameGap / targetFrameTime) - 1;
+        }
+      }
+      lastFrameTime = now;
+    },
+
+    getMetrics: (): PerformanceMetrics => {
+      const times = processingTimes.length > 0 ? processingTimes : [0];
+      return {
+        frameCount,
+        averageProcessingTime: times.reduce((a, b) => a + b, 0) / times.length,
+        minProcessingTime: Math.min(...times),
+        maxProcessingTime: Math.max(...times),
+        droppedFrames,
+      };
+    },
+
+    reset: (): void => {
+      processingTimes.length = 0;
+      frameCount = 0;
+      droppedFrames = 0;
+      lastFrameTime = 0;
+    },
+  };
+}
+

package/src/webrtc/WebRTCBridge.ts

@@ -0,0 +1,127 @@
+import type {
+  WebRTCVideoSourceConfig,
+  WebRTCStreamStats,
+  WebRTCQualitySettings,
+} from './types';
+
+/**
+ * WebRTC Bridge for SmartCamera
+ * 
+ * NOTE: This is a stub implementation. WebRTC functionality is not yet implemented.
+ * This class provides the interface for future WebRTC integration.
+ * 
+ * This class provides a bridge between VisionCamera frames and WebRTC,
+ * allowing camera frames to be streamed via WebRTC peer connections.
+ */
+export class WebRTCBridge {
+  private isInitialized = false;
+  private isStreaming = false;
+  private config: WebRTCVideoSourceConfig | null = null;
+
+  /**
+   * Initialize the WebRTC bridge
+   * 
+   * This must be called before starting streaming.
+   */
+  async initialize(): Promise<void> {
+    if (this.isInitialized) {
+      return;
+    }
+
+    console.warn('[WebRTCBridge] WebRTC is not yet implemented');
+    this.isInitialized = true;
+  }
+
+  /**
+   * Start streaming camera frames via WebRTC
+   * 
+   * @param config - Video source configuration
+   */
+  async startStreaming(config: WebRTCVideoSourceConfig): Promise<void> {
+    if (!this.isInitialized) {
+      await this.initialize();
+    }
+
+    if (this.isStreaming) {
+      console.warn('[WebRTCBridge] Already streaming, stopping first');
+      await this.stopStreaming();
+    }
+
+    console.warn('[WebRTCBridge] WebRTC streaming is not yet implemented');
+    this.config = config;
+    this.isStreaming = true;
+  }
+
+  /**
+   * Stop streaming
+   */
+  async stopStreaming(): Promise<void> {
+    if (!this.isStreaming) {
+      return;
+    }
+
+    this.isStreaming = false;
+    this.config = null;
+  }
+
+  /**
+   * Check if currently streaming
+   */
+  getIsStreaming(): boolean {
+    return this.isStreaming;
+  }
+
+  /**
+   * Get current configuration
+   */
+  getConfig(): WebRTCVideoSourceConfig | null {
+    return this.config;
+  }
+
+  /**
+   * Update quality settings (if supported)
+   * 
+   * @param settings - Quality settings to apply
+   */
+  async updateQuality(settings: WebRTCQualitySettings): Promise<void> {
+    console.log('[WebRTCBridge] Updating quality:', settings);
+  }
+
+  /**
+   * Get current stream statistics
+   */
+  async getStats(): Promise<WebRTCStreamStats | null> {
+    if (!this.isStreaming) {
+      return null;
+    }
+
+    return {
+      frameRate: this.config?.frameRate ?? 0,
+      framesSent: 0,
+      framesDropped: 0,
+      bytesSent: 0,
+      bitrate: 0,
+    };
+  }
+
+  /**
+   * Cleanup and release resources
+   */
+  async destroy(): Promise<void> {
+    await this.stopStreaming();
+    this.isInitialized = false;
+  }
+}
+
+// Singleton instance for convenience
+let bridgeInstance: WebRTCBridge | null = null;
+
+/**
+ * Get the shared WebRTC bridge instance
+ */
+export function getWebRTCBridge(): WebRTCBridge {
+  if (!bridgeInstance) {
+    bridgeInstance = new WebRTCBridge();
+  }
+  return bridgeInstance;
+}