@arfuhad/react-native-smart-camera 0.1.0

package/ARCHITECTURE.md

@@ -0,0 +1,341 @@
+# react-native-smart-camera
+
+Expo-compatible native module for camera preview, face detection, blink detection, and WebRTC streaming.
+
+## Overview
+
+Build a production-ready Expo-compatible native module that provides:
+
+- Camera preview via VisionCamera
+- Real-time face and blink detection using Google ML Kit
+- Static image face detection
+- Native WebRTC bridge for video calling and streaming
+- Expo config plugin for zero-config setup
+
+## Expo Compatibility
+
+| Expo Workflow | Supported | Why |
+|---------------|-----------|-----|
+| Expo Managed | ❌ No | WebRTC + VisionCamera need native code |
+| Expo Dev Client | ✅ Yes | Allows custom native modules |
+| Expo Bare | ✅ Yes | Full native control |
+
+**Requirements:**
+- Expo SDK ≥ 49
+- Expo Dev Client
+- EAS Build
+
+## Architecture
+
+```
+Expo App
+ ├── SmartCamera (JS Component)
+ ├── VisionCamera (native)
+ ├── Frame Processor (worklet)
+ ├── Native WebRTC Bridge
+ │     ├── iOS (Swift)
+ │     └── Android (Kotlin)
+ └── react-native-webrtc
+```
+
+## Installation
+
+```bash
+expo install react-native-smart-camera
+expo prebuild
+expo run:ios
+expo run:android
+```
+
+Or with EAS:
+
+```bash
+eas build --profile development
+```
+
+## Usage
+
+```tsx
+import { SmartCamera } from 'react-native-smart-camera';
+
+<SmartCamera
+  camera="front"
+  faceDetection={{
+    enabled: true,
+    performanceMode: 'fast',
+    landmarkMode: 'all',
+    classificationMode: 'all',
+  }}
+  blinkDetection
+  onBlinkDetected={handleBlink}
+  onFaceDetected={handleFaces}
+  webrtc={{
+    enabled: true,
+    peerConnection,
+    mode: 'call',
+  }}
+/>
+```
+
+---
+
+## API Reference
+
+### SmartCamera Component Props
+
+```typescript
+interface SmartCameraProps {
+  // Camera settings
+  camera?: 'front' | 'back';
+  fps?: number;
+  style?: ViewStyle;
+  
+  // Face Detection Options
+  faceDetection?: FaceDetectionConfig;
+  
+  // Blink Detection
+  blinkDetection?: boolean;
+  onBlinkDetected?: (event: BlinkEvent) => void;
+  
+  // Face Detection Callback
+  onFaceDetected?: (faces: Face[]) => void;
+  
+  // WebRTC Configuration
+  webrtc?: WebRTCConfig;
+}
+```
+
+---
+
+## Face Detection Options
+
+### Common Options (Frame Processor and Static Images)
+
+| Option | Description | Default | Options |
+|--------|-------------|---------|---------|
+| `performanceMode` | Favor speed or accuracy when detecting faces | `'fast'` | `'fast'`, `'accurate'` |
+| `landmarkMode` | Whether to identify facial landmarks: eyes, ears, nose, cheeks, mouth | `'none'` | `'none'`, `'all'` |
+| `contourMode` | Whether to detect contours of facial features. Contours are detected for only the most prominent face in an image | `'none'` | `'none'`, `'all'` |
+| `classificationMode` | Whether to classify faces into categories such as 'smiling' and 'eyes open' | `'none'` | `'none'`, `'all'` |
+| `minFaceSize` | Sets the smallest desired face size, expressed as the ratio of the width of the head to width of the image | `0.15` | `number` |
+| `trackingEnabled` | Whether to assign faces an ID to track faces across images. Note: When contour detection is enabled, only one face is detected, so face tracking doesn't produce useful results. Don't enable both contour detection and face tracking | `false` | `boolean` |
+
+### Frame Processor Options
+
+| Option | Description | Default | Options |
+|--------|-------------|---------|---------|
+| `cameraFacing` | Current active camera | `'front'` | `'front'`, `'back'` |
+| `autoMode` | Should handle auto scale (face bounds, contour and landmarks) and rotation on native side? If disabled, all detection results will be relative to frame coordinates, not to screen/preview. You shouldn't use this option if you want to draw on screen using Skia Frame Processor | `false` | `boolean` |
+| `windowWidth` | Required if you want to use `autoMode`. You must handle your own logic to get screen sizes, with or without statusbar size, etc. | `1.0` | `number` |
+| `windowHeight` | Required if you want to use `autoMode`. You must handle your own logic to get screen sizes, with or without statusbar size, etc. | `1.0` | `number` |
+
+### Static Images Options
+
+| Option | Description | Default | Options |
+|--------|-------------|---------|---------|
+| `image` | Image source for static face detection | - | `number`, `string`, `{ uri: string }` |
+
+---
+
+## Types
+
+```typescript
+// Face Detection Options
+interface FaceDetectionOptions {
+  performanceMode?: 'fast' | 'accurate';
+  landmarkMode?: 'none' | 'all';
+  contourMode?: 'none' | 'all';
+  classificationMode?: 'none' | 'all';
+  minFaceSize?: number;
+  trackingEnabled?: boolean;
+}
+
+// Frame Processor Options
+interface FrameProcessorOptions extends FaceDetectionOptions {
+  cameraFacing?: 'front' | 'back';
+  autoMode?: boolean;
+  windowWidth?: number;
+  windowHeight?: number;
+}
+
+// Static Image Options
+interface StaticImageOptions extends FaceDetectionOptions {
+  image: number | string | { uri: string };
+}
+
+// Face Detection Result
+interface Face {
+  bounds: { x: number; y: number; width: number; height: number };
+  landmarks?: FaceLandmarks;
+  contours?: FaceContours;
+  smilingProbability?: number;
+  leftEyeOpenProbability?: number;
+  rightEyeOpenProbability?: number;
+  trackingId?: number;
+}
+
+// Blink Event
+interface BlinkEvent {
+  timestamp: number;
+  leftEyeOpen: number;  // 0.0 - 1.0
+  rightEyeOpen: number; // 0.0 - 1.0
+  isBlink: boolean;
+  faceId?: number;
+}
+
+// WebRTC Configuration
+interface WebRTCConfig {
+  enabled: boolean;
+  peerConnection?: RTCPeerConnection;
+  mode?: 'call' | 'stream';
+  videoConstraints?: {
+    width?: number;
+    height?: number;
+    frameRate?: number;
+  };
+}
+```
+
+---
+
+## Frame Processor Functions
+
+```typescript
+import { detectFaces, detectBlink } from 'react-native-smart-camera';
+
+// Detect faces in a frame
+const faces = detectFaces(frame, {
+  performanceMode: 'fast',
+  landmarkMode: 'all',
+});
+
+// Detect blink in a frame
+const blinkEvent = detectBlink(frame, {
+  classificationMode: 'all',
+});
+```
+
+---
+
+## Static Image Detection
+
+```typescript
+import { detectFacesInImage } from 'react-native-smart-camera';
+
+const faces = await detectFacesInImage({
+  image: require('./photo.jpg'),
+  performanceMode: 'accurate',
+  landmarkMode: 'all',
+  contourMode: 'all',
+});
+```
+
+---
+
+## WebRTC Hooks
+
+```typescript
+import { useSmartCameraWebRTC } from 'react-native-smart-camera';
+
+const { videoTrack, startStreaming, stopStreaming, switchCamera } = useSmartCameraWebRTC({
+  enabled: true,
+  peerConnection,
+  mode: 'call',
+});
+```
+
+---
+
+## Expo Config Plugin
+
+Add to your `app.json`:
+
+```json
+{
+  "plugins": ["react-native-smart-camera"]
+}
+```
+
+The plugin automatically:
+- Adds camera permissions
+- Adds microphone permissions
+- Adds required iOS frameworks
+- Configures Android Proguard rules
+
+---
+
+## Project Structure
+
+```
+react-native-smart-camera/
+├── src/
+│   ├── index.ts
+│   ├── SmartCamera.tsx
+│   ├── types.ts
+│   ├── hooks/
+│   │   ├── useSmartCamera.ts
+│   │   ├── useBlinkDetection.ts
+│   │   ├── useFaceDetection.ts
+│   │   └── useSmartCameraWebRTC.ts
+│   ├── detection/
+│   │   ├── blinkProcessor.ts
+│   │   ├── faceDetector.ts
+│   │   └── staticImageDetector.ts
+│   └── webrtc/
+│       ├── WebRTCBridge.ts
+│       └── types.ts
+├── android/
+│   ├── src/main/java/expo/modules/smartcamera/
+│   │   ├── SmartCameraModule.kt
+│   │   ├── SmartCameraView.kt
+│   │   ├── MLKitBridge.kt
+│   │   └── WebRTCFrameBridge.kt
+│   └── build.gradle
+├── ios/
+│   ├── SmartCameraModule.swift
+│   ├── SmartCameraView.swift
+│   ├── MLKitBridge.swift
+│   ├── WebRTCFrameBridge.swift
+│   └── SmartCamera.podspec
+├── plugin/
+│   ├── index.ts
+│   ├── withSmartCameraIOS.ts
+│   └── withSmartCameraAndroid.ts
+├── example/
+│   ├── App.tsx
+│   ├── app.json
+│   └── package.json
+├── app.plugin.js
+├── package.json
+├── tsconfig.json
+└── README.md
+```
+
+---
+
+## Limitations
+
+- ❌ Not supported in Expo Go
+- ❌ Requires Dev Client or Bare Workflow
+- ❌ Native build required (via EAS or local)
+
+---
+
+## Peer Dependencies
+
+```json
+{
+  "peerDependencies": {
+    "react-native-vision-camera": ">=3.0.0",
+    "react-native-webrtc": ">=118.0.0",
+    "react-native-worklets-core": ">=1.0.0"
+  }
+}
+```
+
+---
+
+## License
+
+MIT
+

package/README.md

@@ -0,0 +1,154 @@
+# react-native-smart-camera
+
+Expo-compatible native module for camera preview, face detection, blink detection, and WebRTC streaming.
+
+## Features
+
+- 📷 Camera preview via VisionCamera
+- 👁️ Real-time face detection with Google ML Kit
+- 😉 Blink detection with configurable sensitivity
+- 📡 Native WebRTC bridge for video calling and streaming
+- 🔌 Expo config plugin for zero-config setup
+- 📱 Static image face detection
+
+## Expo Compatibility
+
+| Expo Workflow   | Supported | Notes                              |
+| --------------- | --------- | ---------------------------------- |
+| Expo Managed    | ❌ No     | Requires native code               |
+| Expo Dev Client | ✅ Yes    | Recommended for development        |
+| Expo Bare       | ✅ Yes    | Full native control                |
+
+**Requirements:**
+- Expo SDK ≥ 49
+- Expo Dev Client or Bare Workflow
+- EAS Build or local native builds
+
+## Installation
+
+```bash
+# Install the package
+npx expo install react-native-smart-camera
+
+# Install peer dependencies
+npx expo install react-native-vision-camera react-native-webrtc react-native-worklets-core
+
+# Rebuild native code
+npx expo prebuild
+npx expo run:ios
+# or
+npx expo run:android
+```
+
+## Expo Config Plugin
+
+Add to your `app.json` or `app.config.js`:
+
+```json
+{
+  "plugins": [
+    [
+      "react-native-smart-camera",
+      {
+        "cameraPermissionText": "Allow camera access for face detection",
+        "microphonePermissionText": "Allow microphone for audio streaming"
+      }
+    ]
+  ]
+}
+```
+
+## Usage
+
+### Basic Camera Preview
+
+```tsx
+import { SmartCamera } from 'react-native-smart-camera';
+
+export default function App() {
+  return (
+    <SmartCamera
+      camera="front"
+      style={{ flex: 1 }}
+    />
+  );
+}
+```
+
+### Face Detection
+
+```tsx
+import { SmartCamera, Face } from 'react-native-smart-camera';
+
+export default function App() {
+  const handleFaces = (faces: Face[]) => {
+    console.log(`Detected ${faces.length} faces`);
+  };
+
+  return (
+    <SmartCamera
+      camera="front"
+      faceDetection={{
+        enabled: true,
+        performanceMode: 'fast',
+        landmarkMode: 'all',
+        classificationMode: 'all',
+      }}
+      onFaceDetected={handleFaces}
+      style={{ flex: 1 }}
+    />
+  );
+}
+```
+
+### Blink Detection
+
+```tsx
+import { SmartCamera, BlinkEvent } from 'react-native-smart-camera';
+
+export default function App() {
+  const handleBlink = (event: BlinkEvent) => {
+    console.log('Blink detected!', event);
+  };
+
+  return (
+    <SmartCamera
+      camera="front"
+      blinkDetection
+      onBlinkDetected={handleBlink}
+      style={{ flex: 1 }}
+    />
+  );
+}
+```
+
+### Static Image Detection
+
+```tsx
+import { detectFacesInImage } from 'react-native-smart-camera';
+
+const faces = await detectFacesInImage({
+  image: require('./photo.jpg'),
+  performanceMode: 'accurate',
+  landmarkMode: 'all',
+});
+```
+
+## Face Detection Options
+
+| Option             | Description                                     | Default   | Options               |
+| ------------------ | ----------------------------------------------- | --------- | --------------------- |
+| `performanceMode`  | Speed vs accuracy trade-off                     | `'fast'`  | `'fast'`, `'accurate'`|
+| `landmarkMode`     | Detect facial landmarks                         | `'none'`  | `'none'`, `'all'`     |
+| `contourMode`      | Detect facial contours                          | `'none'`  | `'none'`, `'all'`     |
+| `classificationMode` | Classify smiling/eyes open                    | `'none'`  | `'none'`, `'all'`     |
+| `minFaceSize`      | Minimum face size ratio                         | `0.15`    | `number`              |
+| `trackingEnabled`  | Track faces across frames                       | `false`   | `boolean`             |
+
+## API Reference
+
+See [ARCHITECTURE.md](./ARCHITECTURE.md) for full API documentation.
+
+## License
+
+MIT

package/android/build.gradle

@@ -0,0 +1,89 @@
+apply plugin: 'com.android.library'
+apply plugin: 'kotlin-android'
+apply plugin: 'maven-publish'
+
+group = 'expo.modules.smartcamera'
+version = '0.1.0'
+
+buildscript {
+    def expoModulesCorePlugin = new File(project(":expo-modules-core").projectDir.absolutePath, "ExpoModulesCorePlugin.gradle")
+    if (expoModulesCorePlugin.exists()) {
+        apply from: expoModulesCorePlugin
+        applyKotlinExpoModulesCorePlugin()
+    }
+
+    // Simple fallback that allows building without expo-modules-core for lint
+    repositories {
+        mavenCentral()
+        google()
+    }
+
+    dependencies {
+        classpath("org.jetbrains.kotlin:kotlin-gradle-plugin:1.9.22")
+    }
+}
+
+afterEvaluate {
+    publishing {
+        publications {
+            release(MavenPublication) {
+                from components.release
+            }
+        }
+        repositories {
+            maven {
+                url = mavenLocal().url
+            }
+        }
+    }
+}
+
+android {
+    namespace "expo.modules.smartcamera"
+    compileSdkVersion safeExtGet("compileSdkVersion", 34)
+
+    defaultConfig {
+        minSdkVersion safeExtGet("minSdkVersion", 23)
+        targetSdkVersion safeExtGet("targetSdkVersion", 34)
+    }
+
+    publishing {
+        singleVariant("release") {
+            withSourcesJar()
+        }
+    }
+
+    lintOptions {
+        abortOnError false
+    }
+
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_17
+        targetCompatibility JavaVersion.VERSION_17
+    }
+
+    kotlinOptions {
+        jvmTarget = JavaVersion.VERSION_17.majorVersion
+    }
+}
+
+repositories {
+    mavenCentral()
+    google()
+}
+
+dependencies {
+    implementation project(':expo-modules-core')
+    implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8:1.9.22"
+    
+    // Kotlin Coroutines
+    implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:1.7.3"
+    implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.7.3"
+    
+    // Google ML Kit Face Detection
+    implementation 'com.google.mlkit:face-detection:16.1.6'
+}
+
+def safeExtGet(prop, fallback) {
+    rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,2 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+</manifest>

package/android/src/main/java/expo/modules/smartcamera/ImageLoader.kt

@@ -0,0 +1,106 @@
+package expo.modules.smartcamera
+
+import android.graphics.Bitmap
+import android.graphics.BitmapFactory
+import android.net.Uri
+import android.util.Base64
+import android.util.Log
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+import java.io.File
+import java.net.URL
+
+/**
+ * Utility class for loading images from various sources
+ */
+class ImageLoader {
+    companion object {
+        private const val TAG = "ImageLoader"
+    }
+    
+    /**
+     * Load an image from various sources (suspending function for async loading)
+     * 
+     * @param source Image source - can be String URI, Map with "uri" key, or resource ID
+     * @return Bitmap
+     * @throws IllegalArgumentException if the source is invalid
+     */
+    suspend fun loadImage(source: Any): Bitmap = withContext(Dispatchers.IO) {
+        when (source) {
+            is String -> loadFromString(source)
+            is Map<*, *> -> {
+                val uri = source["uri"] as? String
+                val base64 = source["base64"] as? String
+                
+                when {
+                    uri != null -> loadFromString(uri)
+                    base64 != null -> loadFromBase64(base64)
+                    else -> throw IllegalArgumentException("Invalid image source map - must contain 'uri' or 'base64'")
+                }
+            }
+            is Number -> throw IllegalArgumentException("Loading from resource ID not supported. Use a URI instead.")
+            else -> throw IllegalArgumentException("Unsupported image source type: ${source::class.java.simpleName}")
+        }
+    }
+    
+    private fun loadFromString(source: String): Bitmap {
+        return when {
+            source.startsWith("data:image") -> {
+                // Base64 data URI
+                val base64Data = source.substringAfter("base64,")
+                loadFromBase64(base64Data)
+            }
+            source.startsWith("http://") || source.startsWith("https://") -> {
+                loadFromUrl(source)
+            }
+            source.startsWith("file://") -> {
+                loadFromFile(source.removePrefix("file://"))
+            }
+            else -> {
+                // Try as file path
+                loadFromFile(source)
+            }
+        }
+    }
+    
+    private fun loadFromBase64(base64: String): Bitmap {
+        return try {
+            val decodedBytes = Base64.decode(base64, Base64.DEFAULT)
+            BitmapFactory.decodeByteArray(decodedBytes, 0, decodedBytes.size)
+                ?: throw IllegalStateException("Failed to decode base64 image data")
+        } catch (e: Exception) {
+            Log.e(TAG, "Failed to decode base64 image", e)
+            throw IllegalArgumentException("Failed to decode base64 image: ${e.message}", e)
+        }
+    }
+    
+    private fun loadFromUrl(url: String): Bitmap {
+        return try {
+            val connection = URL(url).openConnection()
+            connection.connectTimeout = 10000
+            connection.readTimeout = 30000
+            connection.doInput = true
+            connection.connect()
+            val inputStream = connection.getInputStream()
+            BitmapFactory.decodeStream(inputStream)
+                ?: throw IllegalStateException("Failed to decode image from URL")
+        } catch (e: Exception) {
+            Log.e(TAG, "Failed to load image from URL: $url", e)
+            throw IllegalArgumentException("Failed to load image from URL: ${e.message}", e)
+        }
+    }
+    
+    private fun loadFromFile(path: String): Bitmap {
+        return try {
+            val file = File(path)
+            if (!file.exists()) {
+                throw IllegalArgumentException("File not found: $path")
+            }
+            BitmapFactory.decodeFile(path)
+                ?: throw IllegalStateException("Failed to decode image from file")
+        } catch (e: Exception) {
+            Log.e(TAG, "Failed to load image from file: $path", e)
+            throw IllegalArgumentException("Failed to load image from file: ${e.message}", e)
+        }
+    }
+}