@capgo/camera-preview 7.3.9 → 7.4.0-beta.2

package/ios/{Plugin → Sources/CapgoCameraPreview}/Plugin.swift

@@ -1,6 +1,8 @@
 import Foundation
 import Capacitor
 import AVFoundation
+import Photos
+import CoreImage
 
 extension UIWindow {
     static var isLandscape: Bool {
@@ -47,7 +49,14 @@ public class CameraPreview: CAPPlugin, CAPBridgedPlugin {
         CAPPluginMethod(name: "startRecordVideo", returnType: CAPPluginReturnPromise),
         CAPPluginMethod(name: "stopRecordVideo", returnType: CAPPluginReturnPromise),
         CAPPluginMethod(name: "getTempFilePath", returnType: CAPPluginReturnPromise),
-        CAPPluginMethod(name: "getSupportedPictureSizes", returnType: CAPPluginReturnPromise)
+        CAPPluginMethod(name: "getSupportedPictureSizes", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "isRunning", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "getAvailableDevices", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "getZoom", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "setZoom", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "getFlashMode", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "setDeviceId", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "getDeviceId", returnType: CAPPluginReturnPromise)
     ]
     // Camera state tracking
     private var isInitializing: Bool = false
@@ -68,6 +77,39 @@ public class CameraPreview: CAPPlugin, CAPBridgedPlugin {
     var highResolutionOutput: Bool = false
     var disableAudio: Bool = false
 
+    // MARK: - Transparency Methods
+    
+    private func makeWebViewTransparent() {
+        guard let webView = self.webView else { return }
+        
+        // Define a recursive function to traverse the view hierarchy
+        func makeSubviewsTransparent(_ view: UIView) {
+            // Set the background color to clear
+            view.backgroundColor = .clear
+            
+            // Recurse for all subviews
+            for subview in view.subviews {
+                makeSubviewsTransparent(subview)
+            }
+        }
+        
+        // Set the main webView to be transparent
+        webView.isOpaque = false
+        webView.backgroundColor = .clear
+        
+        // Recursively make all subviews transparent
+        makeSubviewsTransparent(webView)
+        
+        // Also ensure the webview's container is transparent
+        webView.superview?.backgroundColor = .clear
+        
+        // Force a layout pass to apply changes
+        DispatchQueue.main.async {
+            webView.setNeedsLayout()
+            webView.layoutIfNeeded()
+        }
+    }
+
     @objc func rotated() {
         guard let previewView = self.previewView,
               let posX = self.posX,
@@ -105,6 +147,27 @@ public class CameraPreview: CAPPlugin, CAPBridgedPlugin {
         }
 
         cameraController.updateVideoOrientation()
+        
+        // Ensure webview remains transparent after rotation
+        if self.isInitialized {
+            self.makeWebViewTransparent()
+        }
+    }
+    
+    @objc func appDidBecomeActive() {
+        if self.isInitialized {
+            DispatchQueue.main.async {
+                self.makeWebViewTransparent()
+            }
+        }
+    }
+    
+    @objc func appWillEnterForeground() {
+        if self.isInitialized {
+            DispatchQueue.main.async {
+                self.makeWebViewTransparent()
+            }
+        }
     }
 
     struct CameraInfo {
@@ -119,8 +182,11 @@ public class CameraPreview: CAPPlugin, CAPBridgedPlugin {
         // Discover all available cameras
         let deviceTypes: [AVCaptureDevice.DeviceType] = [
             .builtInWideAngleCamera,
-            .builtInTelephotoCamera,
             .builtInUltraWideCamera,
+            .builtInTelephotoCamera,
+            .builtInDualCamera,
+            .builtInDualWideCamera,
+            .builtInTripleCamera,
             .builtInTrueDepthCamera
         ]
 
@@ -197,6 +263,7 @@ public class CameraPreview: CAPPlugin, CAPBridgedPlugin {
         self.isInitializing = true
 
         self.cameraPosition = call.getString("position") ?? "rear"
+        let deviceId = call.getString("deviceId")
         let cameraMode = call.getBool("cameraMode") ?? false
         self.highResolutionOutput = call.getBool("enableHighResolution") ?? false
         self.cameraController.highResolutionOutput = self.highResolutionOutput
@@ -218,7 +285,7 @@ public class CameraPreview: CAPPlugin, CAPBridgedPlugin {
         }
 
         self.rotateWhenOrientationChanged = call.getBool("rotateWhenOrientationChanged") ?? true
-        self.toBack = call.getBool("toBack") ?? false
+        self.toBack = call.getBool("toBack") ?? true
         self.storeToFile = call.getBool("storeToFile") ?? false
         self.enableZoom = call.getBool("enableZoom") ?? false
         self.disableAudio = call.getBool("disableAudio") ?? false
@@ -233,7 +300,7 @@ public class CameraPreview: CAPPlugin, CAPBridgedPlugin {
                 if self.cameraController.captureSession?.isRunning ?? false {
                     call.reject("camera already started")
                 } else {
-                    self.cameraController.prepare(cameraPosition: self.cameraPosition, disableAudio: self.disableAudio, cameraMode: cameraMode) {error in
+                    self.cameraController.prepare(cameraPosition: self.cameraPosition, deviceId: deviceId, disableAudio: self.disableAudio, cameraMode: cameraMode) {error in
                         if let error = error {
                             print(error)
                             call.reject(error.localizedDescription)
@@ -241,9 +308,10 @@ public class CameraPreview: CAPPlugin, CAPBridgedPlugin {
                         }
                         let height = self.paddingBottom != nil ? self.height! - self.paddingBottom!: self.height!
                         self.previewView = UIView(frame: CGRect(x: self.posX ?? 0, y: self.posY ?? 0, width: self.width!, height: height))
-                        self.webView?.isOpaque = false
-                        self.webView?.backgroundColor = UIColor.clear
-                        self.webView?.scrollView.backgroundColor = UIColor.clear
+                        
+                        // Make webview transparent - comprehensive approach
+                        self.makeWebViewTransparent()
+                        
                         self.webView?.superview?.addSubview(self.previewView)
                         if self.toBack! {
                             self.webView?.superview?.bringSubviewToFront(self.webView!)
@@ -256,6 +324,10 @@ public class CameraPreview: CAPPlugin, CAPBridgedPlugin {
                         if self.rotateWhenOrientationChanged == true {
                             NotificationCenter.default.addObserver(self, selector: #selector(CameraPreview.rotated), name: UIDevice.orientationDidChangeNotification, object: nil)
                         }
+                        
+                        // Add observers for app state changes to maintain transparency
+                        NotificationCenter.default.addObserver(self, selector: #selector(CameraPreview.appDidBecomeActive), name: UIApplication.didBecomeActiveNotification, object: nil)
+                        NotificationCenter.default.addObserver(self, selector: #selector(CameraPreview.appWillEnterForeground), name: UIApplication.willEnterForegroundNotification, object: nil)
 
                         self.isInitializing = false
                         self.isInitialized = true
@@ -273,34 +345,38 @@ public class CameraPreview: CAPPlugin, CAPBridgedPlugin {
             call.reject("Camera not initialized")
             return
         }
-        
+
         DispatchQueue.main.async { [weak self] in
             guard let self = self else {
                 call.reject("Camera controller deallocated")
                 return
             }
-            
+
             // Disable user interaction during flip
             self.previewView.isUserInteractionEnabled = false
-            
+
             // Perform camera switch on background thread
             DispatchQueue.global(qos: .userInitiated).async {
                 var retryCount = 0
                 let maxRetries = 3
-                
+
                 func attemptFlip() {
                     do {
                         try self.cameraController.switchCameras()
-                        
+
                         DispatchQueue.main.async {
                             self.cameraController.previewLayer?.frame = self.previewView.bounds
                             self.cameraController.previewLayer?.videoGravity = .resizeAspectFill
                             self.previewView.isUserInteractionEnabled = true
+                            
+                            // Ensure webview remains transparent after flip
+                            self.makeWebViewTransparent()
+                            
                             call.resolve()
                         }
                     } catch {
                         retryCount += 1
-                        
+
                         if retryCount < maxRetries {
                             DispatchQueue.global(qos: .userInitiated).asyncAfter(deadline: .now() + 0.5) {
                                 attemptFlip()
@@ -314,7 +390,7 @@ public class CameraPreview: CAPPlugin, CAPBridgedPlugin {
                         }
                     }
                 }
-                
+
                 attemptFlip()
             }
         }
@@ -330,18 +406,21 @@ public class CameraPreview: CAPPlugin, CAPBridgedPlugin {
                 call.reject("camera not initialized")
                 return
             }
-            
+
             // Always attempt to stop and clean up, regardless of captureSession state
             if let previewView = self.previewView {
                 previewView.removeFromSuperview()
                 self.previewView = nil
             }
-            
+
             self.webView?.isOpaque = true
             self.isInitialized = false
             self.isInitializing = false
             self.cameraController.cleanup()
             
+            // Remove notification observers
+            NotificationCenter.default.removeObserver(self)
+
             call.resolve()
         }
     }
@@ -359,43 +438,56 @@ public class CameraPreview: CAPPlugin, CAPBridgedPlugin {
     @objc func capture(_ call: CAPPluginCall) {
         DispatchQueue.main.async {
 
-            let quality: Int? = call.getInt("quality", 85)
-
-            self.cameraController.captureImage { (image, error) in
+            let quality = call.getFloat("quality", 85)
+            let saveToGallery = call.getBool("saveToGallery", false)
 
-                guard let image = image else {
-                    print(error ?? "Image capture error")
-                    guard let error = error else {
-                        call.reject("Image capture error")
-                        return
-                    }
+            self.cameraController.captureImage(quality: quality) { (image, error) in
+                if let error = error {
                     call.reject(error.localizedDescription)
                     return
                 }
-                let imageData: Data?
-                if self.cameraController.currentCameraPosition == .front {
-                    let flippedImage = image.withHorizontallyFlippedOrientation()
-                    imageData = flippedImage.jpegData(compressionQuality: CGFloat(quality!/100))
-                } else {
-                    imageData = image.jpegData(compressionQuality: CGFloat(quality!/100))
+
+                if saveToGallery {
+                    PHPhotoLibrary.shared().performChanges({
+                        PHAssetChangeRequest.creationRequestForAsset(from: image!)
+                    }, completionHandler: { (success, error) in
+                        if !success {
+                            Logger.error("CameraPreview", "Error saving image to gallery", error)
+                        }
+                    })
                 }
 
-                if self.storeToFile == false {
-                    let imageBase64 = imageData?.base64EncodedString()
-                    call.resolve(["value": imageBase64!])
-                } else {
-                    do {
-                        let fileUrl=self.getTempFilePath()
-                        try imageData?.write(to: fileUrl)
-                        call.resolve(["value": fileUrl.absoluteString])
-                    } catch {
-                        call.reject("error writing image to file")
-                    }
+                guard let imageData = image?.jpegData(compressionQuality: CGFloat(quality / 100.0)) else {
+                    call.reject("Failed to get JPEG data from image")
+                    return
                 }
+                
+                let exifData = self.getExifData(from: imageData)
+                let base64Image = imageData.base64EncodedString()
+                
+                var result = JSObject()
+                result["value"] = base64Image
+                result["exif"] = exifData
+                call.resolve(result)
             }
         }
     }
 
+    private func getExifData(from imageData: Data) -> JSObject {
+        guard let imageSource = CGImageSourceCreateWithData(imageData as CFData, nil),
+              let imageProperties = CGImageSourceCopyPropertiesAtIndex(imageSource, 0, nil) as? [String: Any],
+              let exifDict = imageProperties[kCGImagePropertyExifDictionary as String] as? [String: Any] else {
+            return [:]
+        }
+        
+        var exifData = JSObject()
+        for (key, value) in exifDict {
+            exifData[key] = value
+        }
+        
+        return exifData
+    }
+
     @objc func captureSample(_ call: CAPPluginCall) {
         DispatchQueue.main.async {
             let quality: Int? = call.getInt("quality", 85)
@@ -508,4 +600,218 @@ public class CameraPreview: CAPPlugin, CAPBridgedPlugin {
         }
     }
 
+    @objc func isRunning(_ call: CAPPluginCall) {
+        let isRunning = self.isInitialized && (self.cameraController.captureSession?.isRunning ?? false)
+        call.resolve(["isRunning": isRunning])
+    }
+
+    @objc func getAvailableDevices(_ call: CAPPluginCall) {
+        let deviceTypes: [AVCaptureDevice.DeviceType] = [
+            .builtInWideAngleCamera,
+            .builtInUltraWideCamera,
+            .builtInTelephotoCamera,
+            .builtInDualCamera,
+            .builtInDualWideCamera,
+            .builtInTripleCamera,
+            .builtInTrueDepthCamera
+        ]
+
+        let session = AVCaptureDevice.DiscoverySession(
+            deviceTypes: deviceTypes,
+            mediaType: .video,
+            position: .unspecified
+        )
+
+        var devices: [[String: Any]] = []
+
+        // Collect all devices by position
+        for device in session.devices {
+            var lenses: [[String: Any]] = []
+            
+            let constituentDevices = device.isVirtualDevice ? device.constituentDevices : [device]
+            
+            for lensDevice in constituentDevices {
+                var deviceType: String
+                switch lensDevice.deviceType {
+                    case .builtInWideAngleCamera: deviceType = "wideAngle"
+                    case .builtInUltraWideCamera: deviceType = "ultraWide"
+                    case .builtInTelephotoCamera: deviceType = "telephoto"
+                    case .builtInDualCamera: deviceType = "dual"
+                    case .builtInDualWideCamera: deviceType = "dualWide"
+                    case .builtInTripleCamera: deviceType = "triple"
+                    case .builtInTrueDepthCamera: deviceType = "trueDepth"
+                    default: deviceType = "unknown"
+                }
+
+                var baseZoomRatio: Float = 1.0
+                if lensDevice.deviceType == .builtInUltraWideCamera {
+                    baseZoomRatio = 0.5
+                } else if lensDevice.deviceType == .builtInTelephotoCamera {
+                    baseZoomRatio = 2.0 // A common value for telephoto lenses
+                }
+                
+                let lensInfo: [String: Any] = [
+                    "label": lensDevice.localizedName,
+                    "deviceType": deviceType,
+                    "focalLength": 4.25, // Placeholder
+                    "baseZoomRatio": baseZoomRatio,
+                    "minZoom": Float(lensDevice.minAvailableVideoZoomFactor),
+                    "maxZoom": Float(lensDevice.maxAvailableVideoZoomFactor)
+                ]
+                lenses.append(lensInfo)
+            }
+            
+            let deviceData: [String: Any] = [
+                "deviceId": device.uniqueID,
+                "label": device.localizedName,
+                "position": device.position == .front ? "front" : "rear",
+                "lenses": lenses,
+                "minZoom": Float(device.minAvailableVideoZoomFactor),
+                "maxZoom": Float(device.maxAvailableVideoZoomFactor),
+                "isLogical": device.isVirtualDevice
+            ]
+            
+            devices.append(deviceData)
+        }
+
+        call.resolve(["devices": devices])
+    }
+
+    @objc func getZoom(_ call: CAPPluginCall) {
+        guard isInitialized else {
+            call.reject("Camera not initialized")
+            return
+        }
+
+        do {
+            let zoomInfo = try self.cameraController.getZoom()
+            let lensInfo = try self.cameraController.getCurrentLensInfo()
+            
+            var minZoom = zoomInfo.min
+            var maxZoom = zoomInfo.max
+            var currentZoom = zoomInfo.current
+
+            // If using the multi-lens camera, translate the native zoom values for JS
+            if self.cameraController.isUsingMultiLensVirtualCamera {
+                minZoom -= 0.5
+                maxZoom -= 0.5
+                currentZoom -= 0.5
+            }
+
+            call.resolve([
+                "min": minZoom,
+                "max": maxZoom,
+                "current": currentZoom,
+                "lens": [
+                    "focalLength": lensInfo.focalLength,
+                    "deviceType": lensInfo.deviceType,
+                    "baseZoomRatio": lensInfo.baseZoomRatio,
+                    "digitalZoom": Float(currentZoom) / lensInfo.baseZoomRatio
+                ]
+            ])
+        } catch {
+            call.reject("Failed to get zoom: \(error.localizedDescription)")
+        }
+    }
+
+    @objc func setZoom(_ call: CAPPluginCall) {
+        guard isInitialized else {
+            call.reject("Camera not initialized")
+            return
+        }
+
+        guard var level = call.getFloat("level") else {
+            call.reject("level parameter is required")
+            return
+        }
+
+        // If using the multi-lens camera, translate the JS zoom value for the native layer
+        if self.cameraController.isUsingMultiLensVirtualCamera {
+            level += 0.5
+        }
+
+        let ramp = call.getBool("ramp") ?? true
+
+        do {
+            try self.cameraController.setZoom(level: CGFloat(level), ramp: ramp)
+            call.resolve()
+        } catch {
+            call.reject("Failed to set zoom: \(error.localizedDescription)")
+        }
+    }
+
+    @objc func getFlashMode(_ call: CAPPluginCall) {
+        guard isInitialized else {
+            call.reject("Camera not initialized")
+            return
+        }
+
+        do {
+            let flashMode = try self.cameraController.getFlashMode()
+            call.resolve(["flashMode": flashMode])
+        } catch {
+            call.reject("Failed to get flash mode: \(error.localizedDescription)")
+        }
+    }
+
+    @objc func setDeviceId(_ call: CAPPluginCall) {
+        guard isInitialized else {
+            call.reject("Camera not initialized")
+            return
+        }
+
+        guard let deviceId = call.getString("deviceId") else {
+            call.reject("deviceId parameter is required")
+            return
+        }
+
+        DispatchQueue.main.async { [weak self] in
+            guard let self = self else {
+                call.reject("Camera controller deallocated")
+                return
+            }
+
+            // Disable user interaction during device swap
+            self.previewView.isUserInteractionEnabled = false
+
+            DispatchQueue.global(qos: .userInitiated).async {
+                do {
+                    try self.cameraController.swapToDevice(deviceId: deviceId)
+
+                    DispatchQueue.main.async {
+                        self.cameraController.previewLayer?.frame = self.previewView.bounds
+                        self.cameraController.previewLayer?.videoGravity = .resizeAspectFill
+                        self.previewView.isUserInteractionEnabled = true
+                        
+                        // Ensure webview remains transparent after device switch
+                        self.makeWebViewTransparent()
+                        
+                        call.resolve()
+                    }
+                } catch {
+                    DispatchQueue.main.async {
+                        self.previewView.isUserInteractionEnabled = true
+                        call.reject("Failed to swap to device \(deviceId): \(error.localizedDescription)")
+                    }
+                }
+            }
+        }
+    }
+
+        @objc func getDeviceId(_ call: CAPPluginCall) {
+        guard isInitialized else {
+            call.reject("Camera not initialized")
+            return
+        }
+
+        do {
+            let deviceId = try self.cameraController.getCurrentDeviceId()
+            call.resolve(["deviceId": deviceId])
+        } catch {
+            call.reject("Failed to get device ID: \(error.localizedDescription)")
+        }
+    }
+
+
+
 }

package/ios/Tests/CameraPreviewPluginTests/CameraPreviewPluginTests.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

@@ -1,6 +1,6 @@
 {
   "name": "@capgo/camera-preview",
-  "version": "7.3.9",
+  "version": "7.4.0-beta.2",
   "description": "Camera preview",
   "license": "MIT",
   "repository": {