@capgo/camera-preview 7.4.1 → 7.5.0

package/ios/Sources/CapgoCameraPreviewPlugin/CameraController.swift

@@ -70,6 +70,37 @@ class CameraController: NSObject {
 
     // Track whether an aspect ratio was explicitly requested
     var requestedAspectRatio: String?
+    
+    private func calculateAspectRatioFrame(for aspectRatio: String, in bounds: CGRect) -> CGRect {
+        guard let ratio = parseAspectRatio(aspectRatio) else {
+            return bounds
+        }
+        
+        let targetAspectRatio = ratio.width / ratio.height
+        let viewAspectRatio = bounds.width / bounds.height
+        
+        var frame: CGRect
+        
+        if viewAspectRatio > targetAspectRatio {
+            // View is wider than target - fit by height
+            let targetWidth = bounds.height * targetAspectRatio
+            let xOffset = (bounds.width - targetWidth) / 2
+            frame = CGRect(x: xOffset, y: 0, width: targetWidth, height: bounds.height)
+        } else {
+            // View is taller than target - fit by width
+            let targetHeight = bounds.width / targetAspectRatio
+            let yOffset = (bounds.height - targetHeight) / 2
+            frame = CGRect(x: 0, y: yOffset, width: bounds.width, height: targetHeight)
+        }
+        
+        return frame
+    }
+    
+    private func parseAspectRatio(_ aspectRatio: String) -> (width: CGFloat, height: CGFloat)? {
+        let components = aspectRatio.split(separator: ":").compactMap { Float(String($0)) }
+        guard components.count == 2 else { return nil }
+        return (width: CGFloat(components[0]), height: CGFloat(components[1]))
+    }
 }
 
 extension CameraController {
@@ -416,9 +447,17 @@ extension CameraController {
         }
 
         // Fast configuration without CATransaction overhead
-        // Use resizeAspect to avoid crop when no aspect ratio is requested; otherwise fill
-        previewLayer.videoGravity = (requestedAspectRatio == nil) ? .resizeAspect : .resizeAspectFill
-        previewLayer.frame = view.bounds
+        // Configure video gravity and frame based on aspect ratio
+        if let aspectRatio = requestedAspectRatio {
+            // Calculate the frame based on requested aspect ratio
+            let frame = calculateAspectRatioFrame(for: aspectRatio, in: view.bounds)
+            previewLayer.frame = frame
+            previewLayer.videoGravity = .resizeAspectFill
+        } else {
+            // No specific aspect ratio requested - fill the entire view
+            previewLayer.frame = view.bounds
+            previewLayer.videoGravity = .resizeAspect
+        }
 
         // Insert layer immediately (only if new)
         if previewLayer.superlayer != view.layer {
@@ -433,7 +472,16 @@ extension CameraController {
         // Disable animation for grid overlay creation and positioning
         CATransaction.begin()
         CATransaction.setDisableActions(true)
-        gridOverlayView = GridOverlayView(frame: view.bounds)
+        
+        // Use preview layer frame if aspect ratio is specified, otherwise use full view bounds
+        let gridFrame: CGRect
+        if requestedAspectRatio != nil, let previewLayer = previewLayer {
+            gridFrame = previewLayer.frame
+        } else {
+            gridFrame = view.bounds
+        }
+        
+        gridOverlayView = GridOverlayView(frame: gridFrame)
         gridOverlayView?.gridMode = gridMode
         view.addSubview(gridOverlayView!)
         CATransaction.commit()
@@ -628,8 +676,8 @@ extension CameraController {
         }
     }
 
-    func captureImage(width: Int?, height: Int?, aspectRatio: String?, quality: Float, gpsLocation: CLLocation?, completion: @escaping (UIImage?, Data?, [AnyHashable: Any]?, Error?) -> Void) {
-        print("[CameraPreview] captureImage called - width: \(width ?? -1), height: \(height ?? -1), aspectRatio: \(aspectRatio ?? "nil")")
+    func captureImage(width: Int?, height: Int?, quality: Float, gpsLocation: CLLocation?, completion: @escaping (UIImage?, Data?, [AnyHashable: Any]?, Error?) -> Void) {
+        print("[CameraPreview] captureImage called - width: \(width ?? -1), height: \(height ?? -1)")
 
         guard let photoOutput = self.photoOutput else {
             completion(nil, nil, nil, NSError(domain: "Camera", code: 0, userInfo: [NSLocalizedDescriptionKey: "Photo output is not available"]))
@@ -637,9 +685,12 @@ extension CameraController {
         }
 
         let settings = AVCapturePhotoSettings()
-        // Request highest quality photo capture
+        // Configure photo capture settings
         if #available(iOS 13.0, *) {
-            settings.isHighResolutionPhotoEnabled = true
+            // Enable high resolution capture if max dimensions are specified or no aspect ratio constraint
+            // When aspect ratio is specified WITHOUT max dimensions, use session preset dimensions
+            let shouldUseHighRes = (width != nil || height != nil) || (self.requestedAspectRatio == nil)
+            settings.isHighResolutionPhotoEnabled = shouldUseHighRes
         }
         if #available(iOS 15.0, *) {
             settings.photoQualityPrioritization = .balanced
@@ -683,46 +734,29 @@ extension CameraController {
             var finalImage = image
 
             // Determine what to do based on parameters
-            if let width = width, let height = height {
-                // Specific dimensions requested - resize to exact size
-                finalImage = self.resizeImage(image: image, to: CGSize(width: width, height: height))!
-                print("[CameraPreview] Resized to exact dimensions: \(finalImage.size.width)x\(finalImage.size.height)")
-            } else if let aspectRatio = aspectRatio {
-                // Aspect ratio specified - crop to that ratio
-                let components = aspectRatio.split(separator: ":").compactMap { Double($0) }
-                if components.count == 2 {
-                    // For capture in portrait orientation, swap the aspect ratio (16:9 becomes 9:16)
-                    let isPortrait = image.size.height > image.size.width
-                    let targetAspectRatio = isPortrait ? components[1] / components[0] : components[0] / components[1]
-                    let imageSize = image.size
-                    let originalAspectRatio = imageSize.width / imageSize.height
-
-                    // Only crop if the aspect ratios don't match
-                    if abs(originalAspectRatio - targetAspectRatio) > 0.01 {
-                        var targetSize = imageSize
-
-                        if originalAspectRatio > targetAspectRatio {
-                            // Original is wider than target - fit by height
-                            targetSize.width = imageSize.height * CGFloat(targetAspectRatio)
-                        } else {
-                            // Original is taller than target - fit by width
-                            targetSize.height = imageSize.width / CGFloat(targetAspectRatio)
-                        }
-
-                        // Center crop the image
-                        if let croppedImage = self.cropImageToAspectRatio(image: image, targetSize: targetSize) {
-                            finalImage = croppedImage
-                            print("[CameraPreview] Applied aspect ratio crop: \(finalImage.size.width)x\(finalImage.size.height)")
-                        }
-                    }
+            if width != nil || height != nil {
+                // When max dimensions are specified, we used high-res capture
+                // First crop to aspect ratio if needed, then resize to max dimensions
+                if let aspectRatio = self.requestedAspectRatio {
+                    finalImage = self.cropImageToAspectRatio(image: image, aspectRatio: aspectRatio) ?? image
+                    print("[CameraPreview] Cropped high-res image to aspect ratio \(aspectRatio)")
                 }
-            } else {
-                // No parameters specified - crop to match what's visible in the preview
-                // This ensures we capture exactly what the user sees
-                if let previewLayer = self.previewLayer,
-                   let previewCroppedImage = self.cropImageToMatchPreview(image: image, previewLayer: previewLayer) {
-                    finalImage = previewCroppedImage
-                    print("[CameraPreview] Cropped to match preview: \(finalImage.size.width)x\(finalImage.size.height)")
+                // Then resize to fit within maximum dimensions while maintaining aspect ratio
+                finalImage = self.resizeImageToMaxDimensions(image: finalImage, maxWidth: width, maxHeight: height)!
+                print("[CameraPreview] Resized to max dimensions: \(finalImage.size.width)x\(finalImage.size.height)")
+            } else if let aspectRatio = self.requestedAspectRatio {
+                // No max dimensions specified, but aspect ratio is specified
+                // If we used session preset (low-res), image should already be correct aspect ratio
+                // If we used high-res (shouldn't happen without max dimensions), crop it
+                let imageAspectRatio = image.size.width / image.size.height
+                if let targetRatio = self.parseAspectRatio(aspectRatio) {
+                    let targetAspectRatio = targetRatio.width / targetRatio.height
+                    
+                    // Allow small tolerance for aspect ratio comparison
+                    if abs(imageAspectRatio - targetAspectRatio) > 0.01 {
+                        finalImage = self.cropImageToAspectRatio(image: image, aspectRatio: aspectRatio) ?? image
+                        print("[CameraPreview] Cropped to match aspect ratio \(aspectRatio): \(finalImage.size.width)x\(finalImage.size.height)")
+                    }
                 }
             }
 
@@ -762,27 +796,75 @@ extension CameraController {
     }
 
     func resizeImage(image: UIImage, to size: CGSize) -> UIImage? {
-        let renderer = UIGraphicsImageRenderer(size: size)
+        // Create a renderer with scale 1.0 to ensure we get exact pixel dimensions
+        let format = UIGraphicsImageRendererFormat()
+        format.scale = 1.0
+        let renderer = UIGraphicsImageRenderer(size: size, format: format)
         let resizedImage = renderer.image { (_) in
             image.draw(in: CGRect(origin: .zero, size: size))
         }
         return resizedImage
     }
 
-    func cropImageToAspectRatio(image: UIImage, targetSize: CGSize) -> UIImage? {
-        let imageSize = image.size
-
-        // Calculate the crop rect - center crop
-        let xOffset = (imageSize.width - targetSize.width) / 2
-        let yOffset = (imageSize.height - targetSize.height) / 2
-        let cropRect = CGRect(x: xOffset, y: yOffset, width: targetSize.width, height: targetSize.height)
+    func resizeImageToMaxDimensions(image: UIImage, maxWidth: Int?, maxHeight: Int?) -> UIImage? {
+        let originalSize = image.size
+        let originalAspectRatio = originalSize.width / originalSize.height
+        
+        var targetSize = originalSize
+        
+        if let maxWidth = maxWidth, let maxHeight = maxHeight {
+            // Both dimensions specified - fit within both maximums
+            let maxAspectRatio = CGFloat(maxWidth) / CGFloat(maxHeight)
+            if originalAspectRatio > maxAspectRatio {
+                // Original is wider - fit by width
+                targetSize.width = CGFloat(maxWidth)
+                targetSize.height = CGFloat(maxWidth) / originalAspectRatio
+            } else {
+                // Original is taller - fit by height
+                targetSize.width = CGFloat(maxHeight) * originalAspectRatio
+                targetSize.height = CGFloat(maxHeight)
+            }
+        } else if let maxWidth = maxWidth {
+            // Only width specified - maintain aspect ratio
+            targetSize.width = CGFloat(maxWidth)
+            targetSize.height = CGFloat(maxWidth) / originalAspectRatio
+        } else if let maxHeight = maxHeight {
+            // Only height specified - maintain aspect ratio
+            targetSize.width = CGFloat(maxHeight) * originalAspectRatio
+            targetSize.height = CGFloat(maxHeight)
+        }
+        
+        return resizeImage(image: image, to: targetSize)
+    }
 
-        // Create the cropped image
+    func cropImageToAspectRatio(image: UIImage, aspectRatio: String) -> UIImage? {
+        guard let ratio = parseAspectRatio(aspectRatio) else {
+            return image
+        }
+        
+        let imageSize = image.size
+        let imageAspectRatio = imageSize.width / imageSize.height
+        let targetAspectRatio = ratio.width / ratio.height
+        
+        var cropRect: CGRect
+        
+        if imageAspectRatio > targetAspectRatio {
+            // Image is wider than target - crop horizontally (center crop)
+            let targetWidth = imageSize.height * targetAspectRatio
+            let xOffset = (imageSize.width - targetWidth) / 2
+            cropRect = CGRect(x: xOffset, y: 0, width: targetWidth, height: imageSize.height)
+        } else {
+            // Image is taller than target - crop vertically (center crop)
+            let targetHeight = imageSize.width / targetAspectRatio
+            let yOffset = (imageSize.height - targetHeight) / 2
+            cropRect = CGRect(x: 0, y: yOffset, width: imageSize.width, height: targetHeight)
+        }
+        
         guard let cgImage = image.cgImage,
               let croppedCGImage = cgImage.cropping(to: cropRect) else {
             return nil
         }
-
+        
         return UIImage(cgImage: croppedCGImage, scale: image.scale, orientation: image.imageOrientation)
     }
 

package/ios/Sources/CapgoCameraPreviewPlugin/Plugin.swift

@@ -100,13 +100,7 @@ public class CameraPreview: CAPPlugin, CAPBridgedPlugin, CLLocationManagerDelega
 
     // MARK: - Helper Methods for Aspect Ratio
 
-    /// Validates that aspectRatio and size (width/height) are not both set
-    private func validateAspectRatioParameters(aspectRatio: String?, width: Int?, height: Int?) -> String? {
-        if aspectRatio != nil && (width != nil || height != nil) {
-            return "Cannot set both aspectRatio and size (width/height). Use setPreviewSize after start."
-        }
-        return nil
-    }
+
 
     /// Parses aspect ratio string and returns the appropriate ratio for the current orientation
     private func parseAspectRatio(_ ratio: String, isPortrait: Bool) -> CGFloat {
@@ -579,12 +573,18 @@ public class CameraPreview: CAPPlugin, CAPBridgedPlugin, CLLocationManagerDelega
 
         let initialZoomLevel = call.getFloat("initialZoomLevel")
 
-        // Validate aspect ratio parameters using centralized method
-        if let validationError = validateAspectRatioParameters(aspectRatio: self.aspectRatio, width: call.getInt("width"), height: call.getInt("height")) {
-            call.reject(validationError)
+        // Check for conflict between aspectRatio and size (width/height)
+        let hasAspectRatio = call.getString("aspectRatio") != nil
+        let hasWidth = call.getInt("width") != nil
+        let hasHeight = call.getInt("height") != nil
+        
+        if hasAspectRatio && (hasWidth || hasHeight) {
+            call.reject("Cannot set both aspectRatio and size (width/height). Use setPreviewSize after start.")
             return
         }
 
+
+
         AVCaptureDevice.requestAccess(for: .video, completionHandler: { (granted: Bool) in
 
             guard granted else {
@@ -833,27 +833,10 @@ public class CameraPreview: CAPPlugin, CAPBridgedPlugin, CLLocationManagerDelega
         let withExifLocation = call.getBool("withExifLocation", false)
         let width = call.getInt("width")
         let height = call.getInt("height")
-        let aspectRatio = call.getString("aspectRatio")
-
-        print("[CameraPreview] Raw parameter values - width: \(String(describing: width)), height: \(String(describing: height)), aspectRatio: \(String(describing: aspectRatio))")
 
-        // Check for conflicting parameters using centralized validation
-        if let validationError = validateAspectRatioParameters(aspectRatio: aspectRatio, width: width, height: height) {
-            print("[CameraPreview] Error: \(validationError)")
-            call.reject(validationError)
-            return
-        }
-
-        // When no dimensions are specified, we should capture exactly what's visible in the preview
-        // Don't pass aspectRatio in this case - let the capture method handle preview matching
-        print("[CameraPreview] Capture decision - width: \(width == nil), height: \(height == nil), aspectRatio param: \(aspectRatio == nil)")
-        print("[CameraPreview] Stored aspectRatio: \(self.aspectRatio ?? "nil")")
+        print("[CameraPreview] Raw parameter values - width: \(String(describing: width)), height: \(String(describing: height))")
 
-        // Only pass aspectRatio if explicitly provided in the capture call
-        // Never use the stored aspectRatio when capturing without dimensions
-        let captureAspectRatio: String? = aspectRatio
-
-        print("[CameraPreview] Capture params - quality: \(quality), saveToGallery: \(saveToGallery), withExifLocation: \(withExifLocation), width: \(width ?? -1), height: \(height ?? -1), aspectRatio: \(aspectRatio ?? "nil"), using aspectRatio: \(captureAspectRatio ?? "nil")")
+        print("[CameraPreview] Capture params - quality: \(quality), saveToGallery: \(saveToGallery), withExifLocation: \(withExifLocation), width: \(width ?? -1), height: \(height ?? -1)")
         print("[CameraPreview] Current location: \(self.currentLocation?.description ?? "nil")")
         // Safely read frame from main thread for logging
         let (previewWidth, previewHeight): (CGFloat, CGFloat) = {
@@ -870,7 +853,7 @@ public class CameraPreview: CAPPlugin, CAPBridgedPlugin, CLLocationManagerDelega
         }()
         print("[CameraPreview] Preview dimensions: \(previewWidth)x\(previewHeight)")
 
-        self.cameraController.captureImage(width: width, height: height, aspectRatio: captureAspectRatio, quality: quality, gpsLocation: self.currentLocation) { (image, originalPhotoData, _, error) in
+        self.cameraController.captureImage(width: width, height: height, quality: quality, gpsLocation: self.currentLocation) { (image, originalPhotoData, _, error) in
             print("[CameraPreview] captureImage callback received")
             DispatchQueue.main.async {
                 print("[CameraPreview] Processing capture on main thread")
@@ -895,62 +878,38 @@ public class CameraPreview: CAPPlugin, CAPBridgedPlugin, CLLocationManagerDelega
 
                 print("[CameraPreview] Image data created, size: \(imageDataWithExif.count) bytes")
 
-                if saveToGallery {
-                    print("[CameraPreview] Saving to gallery...")
-                    self.saveImageDataToGallery(imageData: imageDataWithExif) { success, error in
-                        print("[CameraPreview] Save to gallery completed, success: \(success), error: \(error?.localizedDescription ?? "none")")
-                        let exifData = self.getExifData(from: imageDataWithExif)
-
-                        var result = JSObject()
-                        result["exif"] = exifData
-                        result["gallerySaved"] = success
-                        if !success, let error = error {
-                            result["galleryError"] = error.localizedDescription
-                        }
-
-                        if self.storeToFile == false {
-                            let base64Image = imageDataWithExif.base64EncodedString()
-                            result["value"] = base64Image
-                        } else {
-                            do {
-                                let fileUrl = self.getTempFilePath()
-                                try imageDataWithExif.write(to: fileUrl)
-                                result["value"] = fileUrl.absoluteString
-                            } catch {
-                                call.reject("Error writing image to file")
-                            }
-                        }
-
-                        print("[CameraPreview] Resolving capture call with gallery save")
-                        call.resolve(result)
-                    }
+                // Prepare the result first
+                let exifData = self.getExifData(from: imageDataWithExif)
+                
+                var result = JSObject()
+                result["exif"] = exifData
+                
+                if self.storeToFile == false {
+                    let base64Image = imageDataWithExif.base64EncodedString()
+                    result["value"] = base64Image
                 } else {
-                    print("[CameraPreview] Not saving to gallery, returning image data")
-                    let exifData = self.getExifData(from: imageDataWithExif)
-
-                    if self.storeToFile == false {
-                        let base64Image = imageDataWithExif.base64EncodedString()
-                        var result = JSObject()
-                        result["value"] = base64Image
-                        result["exif"] = exifData
+                    do {
+                        let fileUrl = self.getTempFilePath()
+                        try imageDataWithExif.write(to: fileUrl)
+                        result["value"] = fileUrl.absoluteString
+                    } catch {
+                        call.reject("Error writing image to file")
+                        return
+                    }
+                }
 
-                        print("[CameraPreview] base64 - Resolving capture call")
-                        call.resolve(result)
-                    } else {
-                        do {
-                            let fileUrl = self.getTempFilePath()
-                            try imageDataWithExif.write(to: fileUrl)
-                            var result = JSObject()
-                            result["value"] = fileUrl.absoluteString
-                            result["exif"] = exifData
-                            print("[CameraPreview] filePath - Resolving capture call")
-                            call.resolve(result)
-                        } catch {
-                            call.reject("Error writing image to file")
+                // Save to gallery asynchronously if requested
+                if saveToGallery {
+                    print("[CameraPreview] Saving to gallery asynchronously...")
+                    DispatchQueue.global(qos: .utility).async {
+                        self.saveImageDataToGallery(imageData: imageDataWithExif) { success, error in
+                            print("[CameraPreview] Save to gallery completed, success: \(success), error: \(error?.localizedDescription ?? "none")")
                         }
                     }
-
                 }
+                
+                print("[CameraPreview] Resolving capture call immediately")
+                call.resolve(result)
             }
         }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@capgo/camera-preview",
-  "version": "7.4.1",
+  "version": "7.5.0",
   "description": "Camera preview",
   "license": "MIT",
   "repository": {