@capgo/camera-preview 7.4.0-beta.8 → 7.4.0-beta.9

package/README.md

@@ -128,7 +128,7 @@ In your `ios/App/App/Info.plist`, you must provide descriptions for the permissi
 
 - **Saving to Gallery** (`saveToGallery: true`):
   ```xml
-  <key>NSPhotoLibraryAddUsageDescription</key>
+  <key>NSPhotoLibraryUsageDescription</key>
   <string>To save photos to your gallery</string>
   ```
 

package/android/src/main/java/com/ahm/capacitor/camera/preview/CameraXView.java

@@ -492,6 +492,16 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
                             ByteArrayOutputStream stream = new ByteArrayOutputStream();
                             resizedBitmap.compress(Bitmap.CompressFormat.JPEG, quality, stream);
                             bytes = stream.toByteArray();
+                            
+                            // Write EXIF data back to resized image
+                            bytes = writeExifToImageBytes(bytes, exifInterface);
+                        } else {
+                            // For non-resized images, ensure EXIF is saved
+                            exifInterface.saveAttributes();
+                            bytes = new byte[(int) tempFile.length()];
+                            java.io.FileInputStream fis2 = new java.io.FileInputStream(tempFile);
+                            fis2.read(bytes);
+                            fis2.close();
                         }
 
                         if (saveToGallery) {
@@ -680,6 +690,46 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
         {ExifInterface.TAG_Y_RESOLUTION, "YResolution"}
     };
 
+    private byte[] writeExifToImageBytes(byte[] imageBytes, ExifInterface sourceExif) {
+        try {
+            // Create a temporary file to write the image with EXIF
+            File tempExifFile = File.createTempFile("temp_exif", ".jpg", context.getCacheDir());
+            
+            // Write the image bytes to temp file
+            java.io.FileOutputStream fos = new java.io.FileOutputStream(tempExifFile);
+            fos.write(imageBytes);
+            fos.close();
+            
+            // Create new ExifInterface for the temp file and copy all EXIF data
+            ExifInterface newExif = new ExifInterface(tempExifFile.getAbsolutePath());
+            
+            // Copy all EXIF attributes from source to new
+            for (String[] tag : EXIF_TAGS) {
+                String value = sourceExif.getAttribute(tag[0]);
+                if (value != null) {
+                    newExif.setAttribute(tag[0], value);
+                }
+            }
+            
+            // Save the EXIF data
+            newExif.saveAttributes();
+            
+            // Read the file back with EXIF embedded
+            byte[] result = new byte[(int) tempExifFile.length()];
+            java.io.FileInputStream fis = new java.io.FileInputStream(tempExifFile);
+            fis.read(result);
+            fis.close();
+            
+            // Clean up temp file
+            tempExifFile.delete();
+            
+            return result;
+        } catch (Exception e) {
+            Log.e(TAG, "writeExifToImageBytes: Error writing EXIF data", e);
+            return imageBytes; // Return original bytes if error
+        }
+    }
+
     public void captureSample(int quality) {
         Log.d(TAG, "captureSample: Starting sample capture with quality: " + quality);
 

package/ios/Sources/CapgoCameraPreview/Plugin.swift

@@ -4,6 +4,7 @@ import AVFoundation
 import Photos
 import CoreImage
 import CoreLocation
+import MobileCoreServices
 
 
 extension UIWindow {
@@ -676,30 +677,53 @@ public class CameraPreview: CAPPlugin, CAPBridgedPlugin, CLLocationManagerDelega
                     return
                 }
 
+                        var gallerySuccess = true
+            var galleryError: String?
+            
+            let group = DispatchGroup()
+            
+            group.notify(queue: .main) {
+                guard let imageDataWithExif = self.createImageDataWithExif(from: image!, quality: Int(quality), location: withExifLocation ? self.currentLocation : nil) else {
+                    call.reject("Failed to create image data with EXIF")
+                    return
+                }
+
                 if saveToGallery {
-                    PHPhotoLibrary.shared().performChanges({
-                        PHAssetChangeRequest.creationRequestForAsset(from: image!)
-                    }, completionHandler: { (success, error) in
+                    group.enter()
+                    self.saveImageDataToGallery(imageData: imageDataWithExif) { success, error in
+                        gallerySuccess = success
                         if !success {
-                            print("CameraPreview: Error saving image to gallery: \(error?.localizedDescription ?? "Unknown error")")
+                            galleryError = error?.localizedDescription ?? "Unknown error"
+                            print("CameraPreview: Error saving image to gallery: \(galleryError!)")
                         }
-                    })
-                }
-
-                guard let imageData = image?.jpegData(compressionQuality: CGFloat(quality / 100.0)) else {
-                    call.reject("Failed to get JPEG data from image")
-                    return
+                        group.leave()
+                    }
+                    
+                    group.notify(queue: .main) {
+                        let exifData = self.getExifData(from: imageDataWithExif)
+                        let base64Image = imageDataWithExif.base64EncodedString()
+
+                        var result = JSObject()
+                        result["value"] = base64Image
+                        result["exif"] = exifData
+                        result["gallerySaved"] = gallerySuccess
+                        if !gallerySuccess, let error = galleryError {
+                            result["galleryError"] = error
+                        }
+                        
+                        call.resolve(result)
+                    }
+                } else {
+                    let exifData = self.getExifData(from: imageDataWithExif)
+                    let base64Image = imageDataWithExif.base64EncodedString()
+
+                    var result = JSObject()
+                    result["value"] = base64Image
+                    result["exif"] = exifData
+                    
+                    call.resolve(result)
                 }
-
-
-                let exifData = self.getExifData(from: imageData)
-                let base64Image = imageData.base64EncodedString()
-
-
-                var result = JSObject()
-                result["value"] = base64Image
-                result["exif"] = exifData
-                call.resolve(result)
+            }
             }
         }
     }
@@ -735,6 +759,82 @@ public class CameraPreview: CAPPlugin, CAPBridgedPlugin, CLLocationManagerDelega
         return exifData
     }
 
+    private func createImageDataWithExif(from image: UIImage, quality: Int, location: CLLocation?) -> Data? {
+        guard let originalImageData = image.jpegData(compressionQuality: CGFloat(Double(quality) / 100.0)) else {
+            return nil
+        }
+        
+        guard let imageSource = CGImageSourceCreateWithData(originalImageData as CFData, nil),
+              let imageProperties = CGImageSourceCopyPropertiesAtIndex(imageSource, 0, nil) as? [String: Any],
+              let cgImage = image.cgImage else {
+            return originalImageData
+        }
+        
+        let mutableData = NSMutableData()
+        guard let destination = CGImageDestinationCreateWithData(mutableData, kUTTypeJPEG, 1, nil) else {
+            return originalImageData
+        }
+        
+        var finalProperties = imageProperties
+        
+        // Add GPS location if available
+        if let location = location {
+            let formatter = DateFormatter()
+            formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ssZ"
+            formatter.timeZone = TimeZone(abbreviation: "UTC")
+            
+            let gpsDict: [String: Any] = [
+                kCGImagePropertyGPSLatitude as String: abs(location.coordinate.latitude),
+                kCGImagePropertyGPSLatitudeRef as String: location.coordinate.latitude >= 0 ? "N" : "S",
+                kCGImagePropertyGPSLongitude as String: abs(location.coordinate.longitude),
+                kCGImagePropertyGPSLongitudeRef as String: location.coordinate.longitude >= 0 ? "E" : "W",
+                kCGImagePropertyGPSTimeStamp as String: formatter.string(from: location.timestamp),
+                kCGImagePropertyGPSAltitude as String: location.altitude,
+                kCGImagePropertyGPSAltitudeRef as String: location.altitude >= 0 ? 0 : 1
+            ]
+            
+            finalProperties[kCGImagePropertyGPSDictionary as String] = gpsDict
+        }
+        
+        // Add lens information
+        do {
+            let currentZoom = try self.cameraController.getZoom()
+            let lensInfo = try self.cameraController.getCurrentLensInfo()
+            
+            // Create or update EXIF dictionary
+            var exifDict = finalProperties[kCGImagePropertyExifDictionary as String] as? [String: Any] ?? [:]
+            
+            // Add focal length (in mm)
+            exifDict[kCGImagePropertyExifFocalLength as String] = lensInfo.focalLength
+            
+            // Add digital zoom ratio
+            let digitalZoom = Float(currentZoom.current) / lensInfo.baseZoomRatio
+            exifDict[kCGImagePropertyExifDigitalZoomRatio as String] = digitalZoom
+            
+            // Add lens model info
+            exifDict[kCGImagePropertyExifLensModel as String] = lensInfo.deviceType
+            
+            finalProperties[kCGImagePropertyExifDictionary as String] = exifDict
+            
+            // Create or update TIFF dictionary for device info
+            var tiffDict = finalProperties[kCGImagePropertyTIFFDictionary as String] as? [String: Any] ?? [:]
+            tiffDict[kCGImagePropertyTIFFMake as String] = "Apple"
+            tiffDict[kCGImagePropertyTIFFModel as String] = UIDevice.current.model
+            finalProperties[kCGImagePropertyTIFFDictionary as String] = tiffDict
+            
+        } catch {
+            print("CameraPreview: Failed to get lens information: \(error)")
+        }
+        
+        CGImageDestinationAddImage(destination, cgImage, finalProperties as CFDictionary)
+        
+        if CGImageDestinationFinalize(destination) {
+            return mutableData as Data
+        }
+        
+        return originalImageData
+    }
+
     @objc func captureSample(_ call: CAPPluginCall) {
         DispatchQueue.main.async {
             let quality: Int? = call.getInt("quality", 85)
@@ -1081,6 +1181,64 @@ public class CameraPreview: CAPPlugin, CAPBridgedPlugin, CLLocationManagerDelega
         print("CameraPreview: Failed to get location: \(error.localizedDescription)")
     }
 
+    private func saveImageDataToGallery(imageData: Data, completion: @escaping (Bool, Error?) -> Void) {
+        // Check if NSPhotoLibraryUsageDescription is present in Info.plist
+        guard Bundle.main.object(forInfoDictionaryKey: "NSPhotoLibraryUsageDescription") != nil else {
+            let error = NSError(domain: "CameraPreview", code: 2, userInfo: [
+                NSLocalizedDescriptionKey: "NSPhotoLibraryUsageDescription key missing from Info.plist. Add this key with a description of how your app uses photo library access."
+            ])
+            completion(false, error)
+            return
+        }
+        
+        let status = PHPhotoLibrary.authorizationStatus()
+        
+        switch status {
+        case .authorized:
+            performSaveDataToGallery(imageData: imageData, completion: completion)
+        case .notDetermined:
+            PHPhotoLibrary.requestAuthorization { newStatus in
+                DispatchQueue.main.async {
+                    if newStatus == .authorized {
+                        self.performSaveDataToGallery(imageData: imageData, completion: completion)
+                    } else {
+                        completion(false, NSError(domain: "CameraPreview", code: 1, userInfo: [NSLocalizedDescriptionKey: "Photo library access denied"]))
+                    }
+                }
+            }
+        case .denied, .restricted:
+            completion(false, NSError(domain: "CameraPreview", code: 1, userInfo: [NSLocalizedDescriptionKey: "Photo library access denied"]))
+        case .limited:
+            performSaveDataToGallery(imageData: imageData, completion: completion)
+        @unknown default:
+            completion(false, NSError(domain: "CameraPreview", code: 1, userInfo: [NSLocalizedDescriptionKey: "Unknown photo library authorization status"]))
+        }
+    }
+    
+    private func performSaveDataToGallery(imageData: Data, completion: @escaping (Bool, Error?) -> Void) {
+        // Create a temporary file to write the JPEG data with EXIF
+        let tempURL = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString + ".jpg")
+        
+        do {
+            try imageData.write(to: tempURL)
+            
+            PHPhotoLibrary.shared().performChanges({
+                PHAssetChangeRequest.creationRequestForAssetFromImage(atFileURL: tempURL)
+            }, completionHandler: { success, error in
+                // Clean up temporary file
+                try? FileManager.default.removeItem(at: tempURL)
+                
+                DispatchQueue.main.async {
+                    completion(success, error)
+                }
+            })
+        } catch {
+            DispatchQueue.main.async {
+                completion(false, error)
+            }
+        }
+    }
+
     private func updateCameraFrame() {
         guard let width = self.width, var height = self.height, let posX = self.posX, let posY = self.posY else {
             return

package/package.json

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