@arfuhad/react-native-smart-camera 0.1.0

package/ios/SmartCameraView.swift

@@ -0,0 +1,146 @@
+import ExpoModulesCore
+import UIKit
+import AVFoundation
+
+class SmartCameraView: ExpoView {
+    // MARK: - Properties
+    
+    var cameraFacing: AVCaptureDevice.Position = .front {
+        didSet {
+            if cameraFacing != oldValue {
+                setupCamera()
+            }
+        }
+    }
+    
+    var isActive: Bool = true {
+        didSet {
+            if isActive != oldValue {
+                updateCameraState()
+            }
+        }
+    }
+    
+    private var captureSession: AVCaptureSession?
+    private var previewLayer: AVCaptureVideoPreviewLayer?
+    private var videoOutput: AVCaptureVideoDataOutput?
+    
+    // MARK: - Initialization
+    
+    required init(appContext: AppContext? = nil) {
+        super.init(appContext: appContext)
+        setupView()
+    }
+    
+    // MARK: - Setup
+    
+    private func setupView() {
+        backgroundColor = .black
+        clipsToBounds = true
+    }
+    
+    private func setupCamera() {
+        // Remove existing session
+        captureSession?.stopRunning()
+        previewLayer?.removeFromSuperlayer()
+        
+        // Create new session
+        let session = AVCaptureSession()
+        session.sessionPreset = .high
+        
+        // Get camera device
+        guard let device = getCameraDevice() else {
+            print("[SmartCameraView] No camera device available")
+            return
+        }
+        
+        do {
+            let input = try AVCaptureDeviceInput(device: device)
+            
+            if session.canAddInput(input) {
+                session.addInput(input)
+            }
+            
+            // Add video output
+            let output = AVCaptureVideoDataOutput()
+            output.videoSettings = [
+                kCVPixelBufferPixelFormatTypeKey as String: kCVPixelFormatType_32BGRA
+            ]
+            output.alwaysDiscardsLateVideoFrames = true
+            
+            if session.canAddOutput(output) {
+                session.addOutput(output)
+            }
+            
+            videoOutput = output
+            
+            // Setup preview layer
+            let preview = AVCaptureVideoPreviewLayer(session: session)
+            preview.videoGravity = .resizeAspectFill
+            preview.frame = bounds
+            layer.addSublayer(preview)
+            
+            previewLayer = preview
+            captureSession = session
+            
+            // Start session on background thread
+            DispatchQueue.global(qos: .userInitiated).async { [weak self] in
+                self?.captureSession?.startRunning()
+            }
+            
+        } catch {
+            print("[SmartCameraView] Error setting up camera: \(error)")
+        }
+    }
+    
+    private func getCameraDevice() -> AVCaptureDevice? {
+        let deviceTypes: [AVCaptureDevice.DeviceType] = [
+            .builtInWideAngleCamera,
+            .builtInDualCamera,
+            .builtInTrueDepthCamera
+        ]
+        
+        let discoverySession = AVCaptureDevice.DiscoverySession(
+            deviceTypes: deviceTypes,
+            mediaType: .video,
+            position: cameraFacing
+        )
+        
+        return discoverySession.devices.first
+    }
+    
+    private func updateCameraState() {
+        if isActive {
+            DispatchQueue.global(qos: .userInitiated).async { [weak self] in
+                self?.captureSession?.startRunning()
+            }
+        } else {
+            DispatchQueue.global(qos: .userInitiated).async { [weak self] in
+                self?.captureSession?.stopRunning()
+            }
+        }
+    }
+    
+    // MARK: - Layout
+    
+    override func layoutSubviews() {
+        super.layoutSubviews()
+        previewLayer?.frame = bounds
+    }
+    
+    // MARK: - Lifecycle
+    
+    override func didMoveToWindow() {
+        super.didMoveToWindow()
+        if window != nil && captureSession == nil {
+            setupCamera()
+        }
+    }
+    
+    override func removeFromSuperview() {
+        captureSession?.stopRunning()
+        captureSession = nil
+        super.removeFromSuperview()
+    }
+}
+

package/ios/WebRTCFrameBridge.swift

@@ -0,0 +1,150 @@
+import Foundation
+import AVFoundation
+
+// Note: This is a placeholder implementation.
+// In production, you would integrate with WebRTC.framework
+// and react-native-webrtc's RTCVideoSource.
+
+class WebRTCFrameBridge {
+    // MARK: - Properties
+    
+    private var isInitialized = false
+    private var isStreaming = false
+    private var streamWidth: Int = 1280
+    private var streamHeight: Int = 720
+    private var streamFrameRate: Int = 30
+    
+    private var frameQueue: DispatchQueue?
+    private var lastFrameTime: CFTimeInterval = 0
+    private var frameInterval: CFTimeInterval = 1.0 / 30.0
+    
+    // MARK: - Initialization
+    
+    func initialize() async throws {
+        guard !isInitialized else { return }
+        
+        // Initialize WebRTC
+        // In production: RTCInitializeSSL()
+        
+        frameQueue = DispatchQueue(label: "com.smartcamera.webrtc.frame", qos: .userInteractive)
+        isInitialized = true
+        
+        print("[WebRTCFrameBridge] Initialized")
+    }
+    
+    // MARK: - Streaming
+    
+    func startStream(width: Int, height: Int, frameRate: Int) async throws {
+        guard isInitialized else {
+            throw NSError(domain: "WebRTCFrameBridge", code: 1, userInfo: [
+                NSLocalizedDescriptionKey: "WebRTC not initialized"
+            ])
+        }
+        
+        guard !isStreaming else {
+            print("[WebRTCFrameBridge] Already streaming")
+            return
+        }
+        
+        streamWidth = width
+        streamHeight = height
+        streamFrameRate = frameRate
+        frameInterval = 1.0 / Double(frameRate)
+        
+        // In production:
+        // 1. Create RTCVideoSource
+        // 2. Create RTCVideoTrack
+        // 3. Add track to peer connection
+        
+        isStreaming = true
+        print("[WebRTCFrameBridge] Started streaming: \(width)x\(height)@\(frameRate)fps")
+    }
+    
+    func stopStream() async {
+        guard isStreaming else { return }
+        
+        // In production:
+        // 1. Remove track from peer connection
+        // 2. Stop video source
+        
+        isStreaming = false
+        print("[WebRTCFrameBridge] Stopped streaming")
+    }
+    
+    // MARK: - Frame Processing
+    
+    func pushFrame(_ frameData: [String: Any]) {
+        guard isStreaming else { return }
+        
+        // Rate limiting
+        let currentTime = CACurrentMediaTime()
+        guard currentTime - lastFrameTime >= frameInterval else { return }
+        lastFrameTime = currentTime
+        
+        frameQueue?.async { [weak self] in
+            self?.processFrame(frameData)
+        }
+    }
+    
+    func pushSampleBuffer(_ sampleBuffer: CMSampleBuffer) {
+        guard isStreaming else { return }
+        
+        // Rate limiting
+        let currentTime = CACurrentMediaTime()
+        guard currentTime - lastFrameTime >= frameInterval else { return }
+        lastFrameTime = currentTime
+        
+        frameQueue?.async { [weak self] in
+            self?.processSampleBuffer(sampleBuffer)
+        }
+    }
+    
+    private func processFrame(_ frameData: [String: Any]) {
+        // In production:
+        // 1. Convert frame data to RTCVideoFrame
+        // 2. Push to RTCVideoSource
+        
+        // Placeholder - log frame info
+        if let width = frameData["width"], let height = frameData["height"] {
+            // print("[WebRTCFrameBridge] Processing frame: \(width)x\(height)")
+        }
+    }
+    
+    private func processSampleBuffer(_ sampleBuffer: CMSampleBuffer) {
+        guard let pixelBuffer = CMSampleBufferGetImageBuffer(sampleBuffer) else {
+            return
+        }
+        
+        // In production:
+        // 1. Convert CVPixelBuffer to RTCCVPixelBuffer
+        // 2. Create RTCVideoFrame
+        // 3. Push to RTCVideoSource
+        
+        // Example conversion (pseudo-code):
+        /*
+        let rtcPixelBuffer = RTCCVPixelBuffer(pixelBuffer: pixelBuffer)
+        let timeStampNs = Int64(CACurrentMediaTime() * 1_000_000_000)
+        let rotation = RTCVideoRotation._0
+        
+        let frame = RTCVideoFrame(
+            buffer: rtcPixelBuffer,
+            rotation: rotation,
+            timeStampNs: timeStampNs
+        )
+        
+        videoSource?.capturer(self, didCapture: frame)
+        */
+        
+        let width = CVPixelBufferGetWidth(pixelBuffer)
+        let height = CVPixelBufferGetHeight(pixelBuffer)
+        // print("[WebRTCFrameBridge] Processing sample buffer: \(width)x\(height)")
+    }
+    
+    // MARK: - Utilities
+    
+    var currentStreamConfig: (width: Int, height: Int, frameRate: Int)? {
+        guard isStreaming else { return nil }
+        return (streamWidth, streamHeight, streamFrameRate)
+    }
+}
+

package/package.json

@@ -0,0 +1,91 @@
+{
+  "name": "@arfuhad/react-native-smart-camera",
+  "version": "0.1.0",
+  "description": "Expo-compatible native module for camera preview, face detection, blink detection, and WebRTC streaming",
+  "main": "build/index.js",
+  "types": "build/index.d.ts",
+  "scripts": {
+    "build": "expo-module build",
+    "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"
+  },
+  "keywords": [
+    "react-native",
+    "expo",
+    "camera",
+    "face-detection",
+    "blink-detection",
+    "webrtc",
+    "vision-camera",
+    "ml-kit",
+    "expo-module",
+    "frame-processor"
+  ],
+  "files": [
+    "build",
+    "ios",
+    "android",
+    "plugin/build",
+    "app.plugin.js",
+    "expo-module.config.json",
+    "README.md",
+    "ARCHITECTURE.md"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/arfuhad/react-native-smart-camera.git"
+  },
+  "bugs": {
+    "url": "https://github.com/arfuhad/react-native-smart-camera/issues"
+  },
+  "author": "arfuhad",
+  "license": "MIT",
+  "homepage": "https://github.com/arfuhad/react-native-smart-camera#readme",
+  "exports": {
+    ".": {
+      "types": "./build/index.d.ts",
+      "default": "./build/index.js"
+    },
+    "./plugin": {
+      "types": "./plugin/build/index.d.ts",
+      "default": "./plugin/build/index.js"
+    }
+  },
+  "peerDependencies": {
+    "expo": ">=49.0.0",
+    "react": ">=18.0.0",
+    "react-native": ">=0.72.0",
+    "react-native-vision-camera": ">=3.0.0",
+    "react-native-webrtc": ">=118.0.0",
+    "react-native-worklets-core": ">=1.0.0"
+  },
+  "devDependencies": {
+    "@expo/config-plugins": "^7.8.0",
+    "@types/react": "^18.2.0",
+    "expo": "^51.0.0",
+    "expo-module-scripts": "^3.4.1",
+    "expo-modules-core": "^1.11.0",
+    "react": "^18.2.0",
+    "react-native": "^0.74.0",
+    "react-native-vision-camera": "^4.0.0",
+    "react-native-webrtc": "^118.0.7",
+    "react-native-worklets-core": "^1.3.0",
+    "typescript": "^5.3.0"
+  },
+  "peerDependenciesMeta": {
+    "react-native-vision-camera": {
+      "optional": false
+    },
+    "react-native-webrtc": {
+      "optional": true
+    },
+    "react-native-worklets-core": {
+      "optional": false
+    }
+  }
+}

package/plugin/build/index.d.ts

@@ -0,0 +1,28 @@
+import { ConfigPlugin } from '@expo/config-plugins';
+/**
+ * Plugin options for react-native-smart-camera
+ */
+export interface SmartCameraPluginOptions {
+    /**
+     * Custom camera usage description for iOS
+     * @default "This app uses the camera for face detection and video streaming"
+     */
+    cameraPermissionText?: string;
+    /**
+     * Custom microphone usage description for iOS
+     * @default "This app uses the microphone for audio streaming"
+     */
+    microphonePermissionText?: string;
+    /**
+     * Enable ML Kit Face Detection
+     * @default true
+     */
+    enableMLKit?: boolean;
+    /**
+     * Enable WebRTC support
+     * @default true
+     */
+    enableWebRTC?: boolean;
+}
+declare const _default: ConfigPlugin<void | SmartCameraPluginOptions>;
+export default _default;

package/plugin/build/index.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const config_plugins_1 = require("@expo/config-plugins");
+const withSmartCameraIOS_1 = require("./withSmartCameraIOS");
+const withSmartCameraAndroid_1 = require("./withSmartCameraAndroid");
+const pkg = require('../../package.json');
+/**
+ * Expo config plugin for react-native-smart-camera
+ *
+ * This plugin:
+ * - Adds camera and microphone permissions
+ * - Configures iOS frameworks
+ * - Sets up Android Proguard rules
+ * - Adds ML Kit dependencies
+ */
+const withSmartCamera = (config, options = {}) => {
+    const { cameraPermissionText = 'This app uses the camera for face detection and video streaming', microphonePermissionText = 'This app uses the microphone for audio streaming', enableMLKit = true, enableWebRTC = true, } = options ?? {};
+    // Apply iOS configuration
+    config = (0, withSmartCameraIOS_1.withSmartCameraIOS)(config, {
+        cameraPermissionText,
+        microphonePermissionText,
+        enableMLKit,
+        enableWebRTC,
+    });
+    // Apply Android configuration
+    config = (0, withSmartCameraAndroid_1.withSmartCameraAndroid)(config, {
+        enableMLKit,
+        enableWebRTC,
+    });
+    return config;
+};
+exports.default = (0, config_plugins_1.createRunOncePlugin)(withSmartCamera, pkg.name, pkg.version);
+//# sourceMappingURL=data:application/json;base64,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

package/plugin/build/withSmartCameraAndroid.d.ts

@@ -0,0 +1,9 @@
+import { ConfigPlugin } from '@expo/config-plugins';
+export interface AndroidPluginOptions {
+    enableMLKit: boolean;
+    enableWebRTC: boolean;
+}
+/**
+ * Android configuration for react-native-smart-camera
+ */
+export declare const withSmartCameraAndroid: ConfigPlugin<AndroidPluginOptions>;

package/plugin/build/withSmartCameraAndroid.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withSmartCameraAndroid = void 0;
+const config_plugins_1 = require("@expo/config-plugins");
+/**
+ * Add camera and microphone permissions to AndroidManifest.xml
+ */
+const withPermissions = (config, _options) => {
+    return (0, config_plugins_1.withAndroidManifest)(config, (config) => {
+        const manifest = config.modResults;
+        // Ensure permissions array exists
+        if (!manifest.manifest['uses-permission']) {
+            manifest.manifest['uses-permission'] = [];
+        }
+        const permissions = manifest.manifest['uses-permission'];
+        // Camera permission
+        const cameraPermission = 'android.permission.CAMERA';
+        if (!permissions.some((p) => p.$?.['android:name'] === cameraPermission)) {
+            permissions.push({
+                $: { 'android:name': cameraPermission },
+            });
+        }
+        // Microphone permission
+        const micPermission = 'android.permission.RECORD_AUDIO';
+        if (!permissions.some((p) => p.$?.['android:name'] === micPermission)) {
+            permissions.push({
+                $: { 'android:name': micPermission },
+            });
+        }
+        // Camera hardware feature
+        if (!manifest.manifest['uses-feature']) {
+            manifest.manifest['uses-feature'] = [];
+        }
+        const features = manifest.manifest['uses-feature'];
+        const cameraFeature = 'android.hardware.camera';
+        if (!features.some((f) => f.$?.['android:name'] === cameraFeature)) {
+            features.push({
+                $: {
+                    'android:name': cameraFeature,
+                    'android:required': 'false',
+                },
+            });
+        }
+        const cameraAutoFocus = 'android.hardware.camera.autofocus';
+        if (!features.some((f) => f.$?.['android:name'] === cameraAutoFocus)) {
+            features.push({
+                $: {
+                    'android:name': cameraAutoFocus,
+                    'android:required': 'false',
+                },
+            });
+        }
+        return config;
+    });
+};
+/**
+ * Add ML Kit dependency to app build.gradle
+ */
+const withMLKitDependency = (config, options) => {
+    if (!options.enableMLKit) {
+        return config;
+    }
+    return (0, config_plugins_1.withAppBuildGradle)(config, (config) => {
+        const buildGradle = config.modResults;
+        // Check if ML Kit is already added
+        if (!buildGradle.contents.includes('com.google.mlkit:face-detection')) {
+            // Add ML Kit dependency in dependencies block
+            buildGradle.contents = buildGradle.contents.replace(/dependencies\s*{/, `dependencies {
+    // SmartCamera ML Kit Face Detection
+    implementation 'com.google.mlkit:face-detection:16.1.5'`);
+        }
+        return config;
+    });
+};
+/**
+ * Add proguard rules for ML Kit
+ */
+const withProguardRules = (config, options) => {
+    if (!options.enableMLKit) {
+        return config;
+    }
+    return (0, config_plugins_1.withAppBuildGradle)(config, (config) => {
+        const buildGradle = config.modResults;
+        // Check if proguard is already configured for ML Kit
+        if (!buildGradle.contents.includes('mlkit-proguard-rules.pro')) {
+            // Add proguard configuration in release build type
+            buildGradle.contents = buildGradle.contents.replace(/buildTypes\s*{\s*release\s*{/, `buildTypes {
+        release {
+            // SmartCamera ML Kit Proguard rules
+            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'`);
+        }
+        return config;
+    });
+};
+/**
+ * Android configuration for react-native-smart-camera
+ */
+const withSmartCameraAndroid = (config, options) => {
+    // Add permissions
+    config = withPermissions(config, options);
+    // Add ML Kit dependency if enabled
+    config = withMLKitDependency(config, options);
+    // Add proguard rules if ML Kit enabled
+    config = withProguardRules(config, options);
+    return config;
+};
+exports.withSmartCameraAndroid = withSmartCameraAndroid;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"withSmartCameraAndroid.js","sourceRoot":"","sources":["../src/withSmartCameraAndroid.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  ConfigPlugin,\n  withAndroidManifest,\n  withAppBuildGradle,\n  withProjectBuildGradle,\n  AndroidConfig,\n} from '@expo/config-plugins';\n\nexport interface AndroidPluginOptions {\n  enableMLKit: boolean;\n  enableWebRTC: boolean;\n}\n\n/**\n * Add camera and microphone permissions to AndroidManifest.xml\n */\nconst withPermissions: ConfigPlugin<AndroidPluginOptions> = (config, _options) => {\n  return withAndroidManifest(config, (config) => {\n    const manifest = config.modResults;\n\n    // Ensure permissions array exists\n    if (!manifest.manifest['uses-permission']) {\n      manifest.manifest['uses-permission'] = [];\n    }\n\n    const permissions = manifest.manifest['uses-permission'];\n\n    // Camera permission\n    const cameraPermission = 'android.permission.CAMERA';\n    if (!permissions.some((p) => p.$?.['android:name'] === cameraPermission)) {\n      permissions.push({\n        $: { 'android:name': cameraPermission },\n      });\n    }\n\n    // Microphone permission\n    const micPermission = 'android.permission.RECORD_AUDIO';\n    if (!permissions.some((p) => p.$?.['android:name'] === micPermission)) {\n      permissions.push({\n        $: { 'android:name': micPermission },\n      });\n    }\n\n    // Camera hardware feature\n    if (!manifest.manifest['uses-feature']) {\n      manifest.manifest['uses-feature'] = [];\n    }\n\n    const features = manifest.manifest['uses-feature'];\n    const cameraFeature = 'android.hardware.camera';\n    if (!features.some((f) => f.$?.['android:name'] === cameraFeature)) {\n      features.push({\n        $: {\n          'android:name': cameraFeature,\n          'android:required': 'false',\n        },\n      });\n    }\n\n    const cameraAutoFocus = 'android.hardware.camera.autofocus';\n    if (!features.some((f) => f.$?.['android:name'] === cameraAutoFocus)) {\n      features.push({\n        $: {\n          'android:name': cameraAutoFocus,\n          'android:required': 'false',\n        },\n      });\n    }\n\n    return config;\n  });\n};\n\n/**\n * Add ML Kit dependency to app build.gradle\n */\nconst withMLKitDependency: ConfigPlugin<AndroidPluginOptions> = (config, options) => {\n  if (!options.enableMLKit) {\n    return config;\n  }\n\n  return withAppBuildGradle(config, (config) => {\n    const buildGradle = config.modResults;\n\n    // Check if ML Kit is already added\n    if (!buildGradle.contents.includes('com.google.mlkit:face-detection')) {\n      // Add ML Kit dependency in dependencies block\n      buildGradle.contents = buildGradle.contents.replace(\n        /dependencies\\s*{/,\n        `dependencies {\n    // SmartCamera ML Kit Face Detection\n    implementation 'com.google.mlkit:face-detection:16.1.5'`\n      );\n    }\n\n    return config;\n  });\n};\n\n/**\n * Add proguard rules for ML Kit\n */\nconst withProguardRules: ConfigPlugin<AndroidPluginOptions> = (config, options) => {\n  if (!options.enableMLKit) {\n    return config;\n  }\n\n  return withAppBuildGradle(config, (config) => {\n    const buildGradle = config.modResults;\n\n    // Check if proguard is already configured for ML Kit\n    if (!buildGradle.contents.includes('mlkit-proguard-rules.pro')) {\n      // Add proguard configuration in release build type\n      buildGradle.contents = buildGradle.contents.replace(\n        /buildTypes\\s*{\\s*release\\s*{/,\n        `buildTypes {\n        release {\n            // SmartCamera ML Kit Proguard rules\n            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'`\n      );\n    }\n\n    return config;\n  });\n};\n\n/**\n * Android configuration for react-native-smart-camera\n */\nexport const withSmartCameraAndroid: ConfigPlugin<AndroidPluginOptions> = (config, options) => {\n  // Add permissions\n  config = withPermissions(config, options);\n\n  // Add ML Kit dependency if enabled\n  config = withMLKitDependency(config, options);\n\n  // Add proguard rules if ML Kit enabled\n  config = withProguardRules(config, options);\n\n  return config;\n};\n\n"]}

package/plugin/build/withSmartCameraIOS.d.ts

@@ -0,0 +1,11 @@
+import { ConfigPlugin } from '@expo/config-plugins';
+export interface IOSPluginOptions {
+    cameraPermissionText: string;
+    microphonePermissionText: string;
+    enableMLKit: boolean;
+    enableWebRTC: boolean;
+}
+/**
+ * iOS configuration for react-native-smart-camera
+ */
+export declare const withSmartCameraIOS: ConfigPlugin<IOSPluginOptions>;