capacitor-camera-view 1.0.0

package/ios/Sources/CameraViewPlugin/CameraViewPlugin.swift

@@ -0,0 +1,295 @@
+import AVFoundation
+import Capacitor
+import Foundation
+
+/// Please read the Capacitor iOS Plugin Development Guide
+/// here: https://capacitorjs.com/docs/plugins/ios
+@objc(CameraViewPlugin)
+public class CameraViewPlugin: CAPPlugin, CAPBridgedPlugin {
+    public let identifier = "CameraViewPlugin"
+    public let jsName = "CameraView"
+
+    /// Maps string flash mode values to AVCaptureDevice.FlashMode enum values.
+    private let strToFlashModeMap: [String: AVCaptureDevice.FlashMode] = [
+        "off": .off,
+        "on": .on,
+        "auto": .auto,
+    ]
+
+    /// Maps AVCaptureDevice.FlashMode enum values to string values.
+    private let flashModeToStrMap: [AVCaptureDevice.FlashMode: String] = [
+        .off: "off",
+        .on: "on",
+        .auto: "auto",
+    ]
+
+    public let pluginMethods: [CAPPluginMethod] = [
+        CAPPluginMethod(name: "start", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "stop", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "isRunning", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "capture", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "captureSample", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "getAvailableDevices", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "flipCamera", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "getZoom", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "setZoom", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "getFlashMode", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "getSupportedFlashModes", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "setFlashMode", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "checkPermissions", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "requestPermissions", returnType: CAPPluginReturnPromise),
+    ]
+
+    private let implementation = CameraViewManager()
+    private var notificationObserver: NSObjectProtocol?
+
+    override public func load() {
+        // Add observer for barcode detection events
+        notificationObserver = NotificationCenter.default.addObserver(
+            forName: Notification.Name("barcodeDetected"),
+            object: nil,
+            queue: .main
+        ) { [weak self] notification in
+            guard let self = self,
+                  let barcodeData = notification.userInfo as? [String: Any] else {
+                return
+            }
+
+            // Emit event to JS
+            self.notifyListeners("barcodeDetected", data: barcodeData)
+        }
+    }
+
+    deinit {
+        if let observer = notificationObserver {
+            NotificationCenter.default.removeObserver(observer)
+        }
+    }
+
+    @objc func start(_ call: CAPPluginCall) {
+        guard let webView = self.webView else {
+            call.reject("Cannot find web view")
+            return
+        }
+
+        maybeRequestCameraAccess { [weak self] granted in
+            guard granted else {
+                call.reject("Camera access denied")
+                return
+            }
+
+            self?.implementation.startSession(
+                configuration: sessionConfigFromPluginCall(call),
+                webView: webView,
+                completion: { (error) in
+                    if let error = error {
+                        call.reject("Failed to start camera preview", nil, error)
+                        return
+                    }
+                    call.resolve()
+                })
+        }
+    }
+
+    @objc func stop(_ call: CAPPluginCall) {
+        implementation.stopSession()
+        call.resolve()
+    }
+
+    @objc func isRunning(_ call: CAPPluginCall) {
+        call.resolve([
+            "isRunning": implementation.isRunning()
+        ])
+    }
+
+    @objc func capture(_ call: CAPPluginCall) {
+        let quality = call.getDouble("quality", 90.0)
+
+        guard quality >= 0.0 && quality <= 100.0 else {
+            call.reject("Quality must be between 0 and 100")
+            return
+        }
+
+        implementation.capturePhoto(completion: { (image, error) in
+            if let error = error {
+                call.reject("Failed to capture image", nil, error)
+                return
+            }
+
+            guard let image = image else {
+                call.reject("No image data", nil, nil)
+                return
+            }
+
+            guard let imageData = image.jpegData(compressionQuality: quality / 100.0) else {
+                call.reject("Failed to compress image", nil, nil)
+                return
+            }
+
+            call.resolve([
+                "photo": imageData.base64EncodedString()
+            ])
+        })
+    }
+
+    @objc func captureSample(_ call: CAPPluginCall) {
+        let quality = call.getDouble("quality", 90.0)
+
+        guard quality >= 0.0 && quality <= 100.0 else {
+            call.reject("Quality must be between 0 and 100")
+            return
+        }
+
+        implementation.captureSnapshot() { (image, error) in
+            if let error = error {
+                call.reject("Failed to capture frame", nil, error)
+                return
+            }
+
+            guard let image = image else {
+                call.reject("No frame data", nil, nil)
+                return
+            }
+
+            guard let imageData = image.jpegData(compressionQuality: quality / 100.0) else {
+                call.reject("Failed to compress image", nil, nil)
+                return
+            }
+
+            call.resolve([
+                "photo": imageData.base64EncodedString()
+            ])
+        }
+    }
+
+    @objc func getAvailableDevices(_ call: CAPPluginCall) {
+        let devices = implementation.getAvailableDevices()
+
+        var result = JSArray()
+        for device in devices {
+            var deviceInfo = JSObject()
+            deviceInfo["id"] = device.uniqueID
+            deviceInfo["name"] = device.localizedName
+            deviceInfo["position"] = device.position == .front ? "front" : "back"
+            deviceInfo["deviceType"] = convertToStringCameraType(device.deviceType)
+            result.append(deviceInfo)
+        }
+
+        call.resolve([
+            "devices": result
+        ])
+    }
+
+    @objc func flipCamera(_ call: CAPPluginCall) {
+        do {
+            try implementation.flipCamera()
+            call.resolve()
+        } catch {
+            call.reject("Failed to switch camera", nil, error)
+            return
+        }
+    }
+
+    @objc func getZoom(_ call: CAPPluginCall) {
+        let zoom = implementation.getSupportedZoomFactors()
+
+        call.resolve([
+            "min": zoom.min,
+            "max": zoom.max,
+            "current": zoom.current,
+        ])
+    }
+
+    @objc func setZoom(_ call: CAPPluginCall) {
+        guard let level = call.getDouble("level") else {
+            call.reject("Zoom level must be provided")
+            return
+        }
+
+        let ramp = call.getBool("ramp") ?? false
+
+        do {
+            try implementation.setZoomFactor(level, ramp: ramp)
+            call.resolve()
+        } catch {
+            call.reject("Failed to set zoom level", nil, error)
+            return
+        }
+    }
+
+    @objc func getFlashMode(_ call: CAPPluginCall) {
+        let flashMode = implementation.getFlashMode()
+
+        call.resolve([
+            "flashMode": flashMode
+        ])
+    }
+
+    @objc func getSupportedFlashModes(_ call: CAPPluginCall) {
+        let supportedFlashModes = implementation.getSupportedFlashModes()
+        let supportedFlashModeStrArr = supportedFlashModes.map { flashModeToStrMap[$0] }
+
+        call.resolve([
+            "flashModes": supportedFlashModeStrArr
+        ])
+    }
+
+    @objc func setFlashMode(_ call: CAPPluginCall) {
+        guard let mode = call.getString("mode") else {
+            call.reject("Flash mode must be provided")
+            return
+        }
+
+        guard let flashMode = strToFlashModeMap[mode] else {
+            call.reject("Invalid flash mode")
+            return
+        }
+
+        do {
+            try implementation.setFlashMode(flashMode)
+            call.resolve()
+        } catch {
+            call.reject("Failed to set flash mode", nil, error)
+        }
+    }
+
+    @objc override public func checkPermissions(_ call: CAPPluginCall) {
+        let cameraState: String
+
+        switch AVCaptureDevice.authorizationStatus(for: .video) {
+        case .notDetermined:
+            cameraState = "prompt"
+        case .restricted, .denied:
+            cameraState = "denied"
+        case .authorized:
+            cameraState = "granted"
+        @unknown default:
+            cameraState = "prompt"
+        }
+
+        call.resolve([
+            "camera": cameraState
+        ])
+    }
+
+    @objc override public func requestPermissions(_ call: CAPPluginCall) {
+        AVCaptureDevice.requestAccess(for: .video) { [weak self] _ in
+            self?.checkPermissions(call)
+        }
+    }
+
+    private func maybeRequestCameraAccess(completion: @escaping (Bool) -> Void) {
+        let status = AVCaptureDevice.authorizationStatus(for: .video)
+        if status == .authorized {
+            completion(true)
+        } else if status == .notDetermined {
+            AVCaptureDevice.requestAccess(for: .video) { granted in
+                DispatchQueue.main.async {
+                    completion(granted)
+                }
+            }
+        } else {
+            completion(false)
+        }
+    }
+}

package/ios/Sources/CameraViewPlugin/Utils.swift

@@ -0,0 +1,56 @@
+import AVFoundation
+
+/// Converts string camera type identifiers from JavaScript to native AVCaptureDevice.DeviceType values
+/// - Parameter stringType: The string camera type from JavaScript
+/// - Returns: The corresponding AVCaptureDevice.DeviceType or nil if no match
+public func convertToNativeCameraType(_ stringType: String) -> AVCaptureDevice.DeviceType? {
+    switch stringType {
+    case "wideAngle":
+        return .builtInWideAngleCamera
+    case "ultraWide":
+        return .builtInUltraWideCamera
+    case "telephoto":
+        return .builtInTelephotoCamera
+    case "dual":
+        return .builtInDualCamera
+    case "dualWide":
+        return .builtInDualWideCamera
+    case "triple":
+        return .builtInTripleCamera
+    case "trueDepth":
+        return .builtInTrueDepthCamera
+    default:
+        return nil
+    }
+}
+
+/// Converts AVCaptureDevice.DeviceType to JavaScript string value
+/// - Parameter deviceType: The AVCaptureDevice.DeviceType
+/// - Returns: The corresponding string or nil if no match
+public func convertToStringCameraType(_ deviceType: AVCaptureDevice.DeviceType) -> String? {
+    switch deviceType {
+    case .builtInWideAngleCamera:
+        return "wideAngle"
+    case .builtInUltraWideCamera:
+        return "ultraWide"
+    case .builtInTelephotoCamera:
+        return "telephoto"
+    case .builtInDualCamera:
+        return "dual"
+    case .builtInDualWideCamera:
+        return "dualWide"
+    case .builtInTripleCamera:
+        return "triple"
+    case .builtInTrueDepthCamera:
+        return "trueDepth"
+    default:
+        return nil
+    }
+}
+
+/// Converts an array of string camera type identifiers to native AVCaptureDevice.DeviceType values
+/// - Parameter stringTypes: Array of string camera types from JavaScript
+/// - Returns: Array of AVCaptureDevice.DeviceType values (invalid types are filtered out)
+public func convertToNativeCameraTypes(_ stringTypes: [String]) -> [AVCaptureDevice.DeviceType] {
+    return stringTypes.compactMap { convertToNativeCameraType($0) }
+}

package/ios/Tests/CameraViewPluginTests/CameraViewPluginTests.swift

@@ -0,0 +1,15 @@
+import XCTest
+@testable import CameraViewPlugin
+
+class CameraViewTests: XCTestCase {
+    func testEcho() {
+        // This is an example of a functional test case for a plugin.
+        // Use XCTAssert and related functions to verify your tests produce the correct results.
+
+        let implementation = CameraView()
+        let value = "Hello, World!"
+        let result = implementation.echo(value)
+
+        XCTAssertEqual(value, result)
+    }
+}

package/package.json

@@ -0,0 +1,94 @@
+{
+  "name": "capacitor-camera-view",
+  "version": "1.0.0",
+  "description": "A Capacitor plugin for embedding a live camera feed directly into your app.",
+  "main": "dist/plugin.cjs.js",
+  "module": "dist/esm/index.js",
+  "types": "dist/esm/index.d.ts",
+  "unpkg": "dist/plugin.js",
+  "files": [
+    "android/src/main/",
+    "android/build.gradle",
+    "dist/",
+    "ios/Sources",
+    "ios/Tests",
+    "Package.swift",
+    "CapacitorCameraView.podspec"
+  ],
+  "author": "Michael Wolz",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/michaelwolz/capacitor-camera-view.git"
+  },
+  "bugs": {
+    "url": "https://github.com/michaelwolz/capacitor-camera-view/issues"
+  },
+  "keywords": [
+    "capacitor",
+    "plugin",
+    "native"
+  ],
+  "scripts": {
+    "verify": "npm run verify:ios && npm run verify:android && npm run verify:web",
+    "verify:ios": "xcodebuild -scheme CapacitorCameraView -destination generic/platform=iOS",
+    "verify:android": "cd android && ./gradlew clean build test && cd ..",
+    "verify:web": "npm run build",
+    "lint": "npm run eslint",
+    "lint:ios": "npm run swiftlint -- lint",
+    "fmt": "npm run eslint -- --fix && npm run prettier -- --write && npm run swiftlint -- --fix --format",
+    "eslint": "eslint . --ext ts",
+    "prettier": "prettier \"**/*.{css,html,ts,js,java}\" --plugin=prettier-plugin-java",
+    "prettier:check": "prettier --check \"**/*.{css,html,ts,js,java}\" --plugin=prettier-plugin-java",
+    "swiftlint": "node-swiftlint",
+    "docgen": "docgen --api CameraViewPlugin --output-readme README.md --output-json dist/docs.json",
+    "build": "npm run clean && npm run docgen && tsc && rollup -c rollup.config.mjs",
+    "clean": "rimraf ./dist",
+    "watch": "tsc --watch",
+    "prepublishOnly": "npm run build"
+  },
+  "devDependencies": {
+    "@capacitor/android": "^7.3.0",
+    "@capacitor/core": "^7.3.0",
+    "@capacitor/docgen": "^0.3.0",
+    "@capacitor/ios": "^7.3.0",
+    "@commitlint/config-conventional": "^19.8.1",
+    "@ionic/eslint-config": "^0.4.0",
+    "@ionic/prettier-config": "^4.0.0",
+    "@ionic/swiftlint-config": "^2.0.0",
+    "@semantic-release/changelog": "^6.0.3",
+    "@semantic-release/commit-analyzer": "^13.0.1",
+    "@semantic-release/git": "^10.0.1",
+    "@semantic-release/github": "^11.0.3",
+    "@semantic-release/npm": "^12.0.1",
+    "@semantic-release/release-notes-generator": "^14.0.3",
+    "commitlint": "^19.8.1",
+    "eslint": "^8.57.0",
+    "husky": "^9.1.7",
+    "prettier": "^3.5.3",
+    "prettier-plugin-java": "^2.6.8",
+    "prettier-plugin-organize-imports": "^4.1.0",
+    "prettier-plugin-packagejson": "^2.5.15",
+    "rimraf": "^6.0.1",
+    "rollup": "^4.41.1",
+    "semantic-release": "^24.2.5",
+    "swiftlint": "^2.0.0",
+    "typescript": "~4.1.5"
+  },
+  "peerDependencies": {
+    "@capacitor/core": ">=7.0.0"
+  },
+  "prettier": "@ionic/prettier-config",
+  "swiftlint": "@ionic/swiftlint-config",
+  "eslintConfig": {
+    "extends": "@ionic/eslint-config/recommended"
+  },
+  "capacitor": {
+    "ios": {
+      "src": "ios"
+    },
+    "android": {
+      "src": "android"
+    }
+  }
+}