@connectedbits/react-native-image-picker 2.4.16-rc2 → 2.4.17

package/ios/ImagePickerManager.m

@@ -1,19 +1,27 @@
 #import "ImagePickerManager.h"
 #import <React/RCTConvert.h>
-#import <AssetsLibrary/AssetsLibrary.h>
+#import <React/RCTUtils.h>
 #import <AVFoundation/AVFoundation.h>
+#import <CoreLocation/CoreLocation.h>
+#import <ImageIO/ImageIO.h>
 #import <Photos/Photos.h>
-#import <React/RCTUtils.h>
+#import <PhotosUI/PhotosUI.h>
+#import <UniformTypeIdentifiers/UniformTypeIdentifiers.h>
 
-@import MobileCoreServices;
+// NOTE: This module deliberately does not use AssetsLibrary (ALAssetsLibrary). It was
+// deprecated in iOS 9 and, as of iOS 27.2, crashes on first use
+// (-[PLManagedObjectContext setIsBackingALAssetsLibrary:]: unrecognized selector).
+//
+// - Camera capture uses UIImagePickerController (still the supported system camera UI).
+// - Library selection uses PHPickerViewController, which needs no photo library permission.
+//   Location is read from the picked file's EXIF first, then from the PHAsset when the app
+//   already has (full or limited) photo library access.
 
-@interface ImagePickerManager ()
+@interface ImagePickerManager () <PHPickerViewControllerDelegate>
 
 @property (nonatomic, strong) UIImagePickerController *picker;
 @property (nonatomic, strong) RCTResponseSenderBlock callback;
-@property (nonatomic, strong) NSDictionary *defaultOptions;
-@property (nonatomic, retain) NSDictionary *options;
-@property (nonatomic, retain) NSMutableDictionary *response;
+@property (nonatomic, strong) NSDictionary *options;
 @property (nonatomic, strong) NSArray *customButtons;
 
 @end
@@ -22,6 +30,11 @@
 
 RCT_EXPORT_MODULE();
 
++ (BOOL)requiresMainQueueSetup
+{
+    return NO;
+}
+
 RCT_EXPORT_METHOD(launchCamera:(NSDictionary *)options callback:(RCTResponseSenderBlock)callback)
 {
     self.callback = callback;
@@ -45,29 +58,29 @@ RCT_EXPORT_METHOD(showImagePicker:(NSDictionary *)options callback:(RCTResponseS
 
     dispatch_async(dispatch_get_main_queue(), ^{
 
-        NSString *title = [self.options valueForKey:@"title"];
-        if ([title isEqual:[NSNull null]] || title.length == 0) {
+        NSString *title = [self stringOption:@"title"];
+        if (title.length == 0) {
             title = nil; // A more visually appealing UIAlertControl is displayed with a nil title rather than title = @""
         }
-        NSString *cancelTitle = [self.options valueForKey:@"cancelButtonTitle"];
-        NSString *takePhotoButtonTitle = [self.options valueForKey:@"takePhotoButtonTitle"];
-        NSString *chooseFromLibraryButtonTitle = [self.options valueForKey:@"chooseFromLibraryButtonTitle"];        
+        NSString *cancelTitle = [self stringOption:@"cancelButtonTitle"];
+        NSString *takePhotoButtonTitle = [self stringOption:@"takePhotoButtonTitle"];
+        NSString *chooseFromLibraryButtonTitle = [self stringOption:@"chooseFromLibraryButtonTitle"];
 
         UIAlertController *alertController = [UIAlertController alertControllerWithTitle:title message:nil preferredStyle:UIAlertControllerStyleActionSheet];
         alertController.view.tintColor = [RCTConvert UIColor:options[@"tintColor"]];
 
         UIAlertAction *cancelAction = [UIAlertAction actionWithTitle:cancelTitle style:UIAlertActionStyleCancel handler:^(UIAlertAction * action) {
-            self.callback(@[@{@"didCancel": @YES}]); // Return callback for 'cancel' action (if is required)
+            [self sendResponse:@{@"didCancel": @YES}];
         }];
         [alertController addAction:cancelAction];
 
-        if (![takePhotoButtonTitle isEqual:[NSNull null]] && takePhotoButtonTitle.length > 0) {
+        if (takePhotoButtonTitle.length > 0) {
             UIAlertAction *takePhotoAction = [UIAlertAction actionWithTitle:takePhotoButtonTitle style:UIAlertActionStyleDefault handler:^(UIAlertAction * action) {
                 [self actionHandler:action];
             }];
             [alertController addAction:takePhotoAction];
         }
-        if (![chooseFromLibraryButtonTitle isEqual:[NSNull null]] && chooseFromLibraryButtonTitle.length > 0) {
+        if (chooseFromLibraryButtonTitle.length > 0) {
             UIAlertAction *chooseFromLibraryAction = [UIAlertAction actionWithTitle:chooseFromLibraryButtonTitle style:UIAlertActionStyleDefault handler:^(UIAlertAction * action) {
                 [self actionHandler:action];
             }];
@@ -75,11 +88,11 @@ RCT_EXPORT_METHOD(showImagePicker:(NSDictionary *)options callback:(RCTResponseS
         }
 
         // Add custom buttons to action sheet
-        if ([self.options objectForKey:@"customButtons"] && [[self.options objectForKey:@"customButtons"] isKindOfClass:[NSArray class]]) {
+        if ([[self.options objectForKey:@"customButtons"] isKindOfClass:[NSArray class]]) {
             self.customButtons = [self.options objectForKey:@"customButtons"];
-            for (NSString *button in self.customButtons) {
-                NSString *title = [button valueForKey:@"title"];
-                UIAlertAction *customAction = [UIAlertAction actionWithTitle:title style:UIAlertActionStyleDefault handler:^(UIAlertAction * action) {
+            for (NSDictionary *button in self.customButtons) {
+                NSString *buttonTitle = [button valueForKey:@"title"];
+                UIAlertAction *customAction = [UIAlertAction actionWithTitle:buttonTitle style:UIAlertActionStyleDefault handler:^(UIAlertAction * action) {
                     [self actionHandler:action];
                 }];
                 [alertController addAction:customAction];
@@ -94,7 +107,7 @@ RCT_EXPORT_METHOD(showImagePicker:(NSDictionary *)options callback:(RCTResponseS
         alertController.popoverPresentationController.sourceView = root.view;
         alertController.popoverPresentationController.sourceRect = CGRectMake(root.view.bounds.size.width / 2.0, root.view.bounds.size.height, 1.0, 1.0);
 
-        if (UI_USER_INTERFACE_IDIOM() == UIUserInterfaceIdiomPad) {
+        if (UIDevice.currentDevice.userInterfaceIdiom == UIUserInterfaceIdiomPad) {
             alertController.popoverPresentationController.permittedArrowDirections = 0;
             for (id subview in alertController.view.subviews) {
                 if ([subview isMemberOfClass:[UIView class]]) {
@@ -115,19 +128,21 @@ RCT_EXPORT_METHOD(showImagePicker:(NSDictionary *)options callback:(RCTResponseS
     if (results.count > 0) {
         NSString *customButtonStr = [[results objectAtIndex:0] objectForKey:@"name"];
         if (customButtonStr) {
-            self.callback(@[@{@"customButton": customButtonStr}]);
+            [self sendResponse:@{@"customButton": customButtonStr}];
             return;
         }
     }
 
-    if ([action.title isEqualToString:[self.options valueForKey:@"takePhotoButtonTitle"]]) { // Take photo
+    if ([action.title isEqualToString:[self stringOption:@"takePhotoButtonTitle"]]) { // Take photo
         [self launchImagePicker:RNImagePickerTargetCamera];
     }
-    else if ([action.title isEqualToString:[self.options valueForKey:@"chooseFromLibraryButtonTitle"]]) { // Choose from library
+    else if ([action.title isEqualToString:[self stringOption:@"chooseFromLibraryButtonTitle"]]) { // Choose from library
         [self launchImagePicker:RNImagePickerTargetLibrarySingleImage];
     }
 }
 
+#pragma mark - Launching
+
 - (void)launchImagePicker:(RNImagePickerTarget)target options:(NSDictionary *)options
 {
     self.options = options;
@@ -136,508 +151,596 @@ RCT_EXPORT_METHOD(showImagePicker:(NSDictionary *)options callback:(RCTResponseS
 
 - (void)launchImagePicker:(RNImagePickerTarget)target
 {
-    self.picker = [[UIImagePickerController alloc] init];
-
     if (target == RNImagePickerTargetCamera) {
-#if TARGET_IPHONE_SIMULATOR
-        self.callback(@[@{@"error": @"Camera not available on simulator"}]);
-        return;
-#else
-        self.picker.sourceType = UIImagePickerControllerSourceTypeCamera;
-        if ([[self.options objectForKey:@"cameraType"] isEqualToString:@"front"]) {
-            self.picker.cameraDevice = UIImagePickerControllerCameraDeviceFront;
-        }
-        else { // "back"
-            self.picker.cameraDevice = UIImagePickerControllerCameraDeviceRear;
-        }
-#endif
+        [self launchCameraPicker];
+    } else {
+        [self launchLibraryPicker];
     }
-    else { // RNImagePickerTargetLibrarySingleImage
-        self.picker.sourceType = UIImagePickerControllerSourceTypePhotoLibrary;
+}
+
+- (void)launchCameraPicker
+{
+#if TARGET_OS_SIMULATOR
+    [self sendResponse:@{@"error": @"Camera not available on simulator"}];
+#else
+    if (![UIImagePickerController isSourceTypeAvailable:UIImagePickerControllerSourceTypeCamera]) {
+        [self sendResponse:@{@"error": @"Camera not available"}];
+        return;
     }
 
-    if ([[self.options objectForKey:@"mediaType"] isEqualToString:@"video"]
-        || [[self.options objectForKey:@"mediaType"] isEqualToString:@"mixed"]) {
+    UIImagePickerController *picker = [[UIImagePickerController alloc] init];
+    picker.sourceType = UIImagePickerControllerSourceTypeCamera;
+    if ([[self stringOption:@"cameraType"] isEqualToString:@"front"]) {
+        picker.cameraDevice = UIImagePickerControllerCameraDeviceFront;
+    } else {
+        picker.cameraDevice = UIImagePickerControllerCameraDeviceRear;
+    }
 
-        if ([[self.options objectForKey:@"videoQuality"] isEqualToString:@"high"]) {
-            self.picker.videoQuality = UIImagePickerControllerQualityTypeHigh;
-        }
-        else if ([[self.options objectForKey:@"videoQuality"] isEqualToString:@"low"]) {
-            self.picker.videoQuality = UIImagePickerControllerQualityTypeLow;
-        }
-        else {
-            self.picker.videoQuality = UIImagePickerControllerQualityTypeMedium;
+    NSString *mediaType = [self stringOption:@"mediaType"];
+    if ([mediaType isEqualToString:@"video"] || [mediaType isEqualToString:@"mixed"]) {
+        NSString *videoQuality = [self stringOption:@"videoQuality"];
+        if ([videoQuality isEqualToString:@"high"]) {
+            picker.videoQuality = UIImagePickerControllerQualityTypeHigh;
+        } else if ([videoQuality isEqualToString:@"low"]) {
+            picker.videoQuality = UIImagePickerControllerQualityTypeLow;
+        } else {
+            picker.videoQuality = UIImagePickerControllerQualityTypeMedium;
         }
 
         id durationLimit = [self.options objectForKey:@"durationLimit"];
-        if (durationLimit) {
-            self.picker.videoMaximumDuration = [durationLimit doubleValue];
-            self.picker.allowsEditing = NO;
+        if ([durationLimit isKindOfClass:[NSNumber class]]) {
+            picker.videoMaximumDuration = [durationLimit doubleValue];
         }
     }
-    if ([[self.options objectForKey:@"mediaType"] isEqualToString:@"video"]) {
-        self.picker.mediaTypes = @[(NSString *)kUTTypeMovie];
-    } else if ([[self.options objectForKey:@"mediaType"] isEqualToString:@"mixed"]) {
-        self.picker.mediaTypes = @[(NSString *)kUTTypeMovie, (NSString *)kUTTypeImage];
+    if ([mediaType isEqualToString:@"video"]) {
+        picker.mediaTypes = @[UTTypeMovie.identifier];
+    } else if ([mediaType isEqualToString:@"mixed"]) {
+        picker.mediaTypes = @[UTTypeMovie.identifier, UTTypeImage.identifier];
     } else {
-        self.picker.mediaTypes = @[(NSString *)kUTTypeImage];
+        picker.mediaTypes = @[UTTypeImage.identifier];
     }
 
-    if ([[self.options objectForKey:@"allowsEditing"] boolValue]) {
-        self.picker.allowsEditing = true;
-    }
-    self.picker.modalPresentationStyle = UIModalPresentationCurrentContext;
-    self.picker.delegate = self;
+    picker.allowsEditing = [[self.options objectForKey:@"allowsEditing"] boolValue];
+    picker.modalPresentationStyle = UIModalPresentationFullScreen;
+    picker.delegate = self;
+    self.picker = picker;
 
-    // Check permissions
-    void (^showPickerViewController)() = ^void() {
+    [self checkCameraPermissions:^(BOOL granted) {
+        if (!granted) {
+            [self sendResponse:@{@"error": @"Camera permissions not granted"}];
+            return;
+        }
         dispatch_async(dispatch_get_main_queue(), ^{
-            UIViewController *root = RCTPresentedViewController();
-            [root presentViewController:self.picker animated:YES completion:nil];
+            [RCTPresentedViewController() presentViewController:picker animated:YES completion:nil];
         });
-    };
-
-    if (target == RNImagePickerTargetCamera) {
-        [self checkCameraPermissions:^(BOOL granted) {
-            if (!granted) {
-                self.callback(@[@{@"error": @"Camera permissions not granted"}]);
-                return;
-            }
+    }];
+#endif
+}
 
-            showPickerViewController();
-        }];
+- (void)launchLibraryPicker
+{
+    // Passing the shared library gives us assetIdentifiers on results, which lets us fall back to
+    // PHAsset metadata (location, creation date, original filename) when the app has library access.
+    // PHPicker itself needs no permission, so we never block selection on authorization.
+    PHPickerConfiguration *configuration = [[PHPickerConfiguration alloc] initWithPhotoLibrary:[PHPhotoLibrary sharedPhotoLibrary]];
+    configuration.selectionLimit = 1;
+    // Hand back the asset as stored (no transcoding) so EXIF/GPS metadata and GIF frames are preserved.
+    configuration.preferredAssetRepresentationMode = PHPickerConfigurationAssetRepresentationModeCurrent;
+
+    NSString *mediaType = [self stringOption:@"mediaType"];
+    if ([mediaType isEqualToString:@"video"]) {
+        configuration.filter = [PHPickerFilter videosFilter];
+    } else if ([mediaType isEqualToString:@"mixed"]) {
+        configuration.filter = [PHPickerFilter anyFilterMatchingSubfilters:@[[PHPickerFilter imagesFilter], [PHPickerFilter videosFilter]]];
+    } else {
+        configuration.filter = [PHPickerFilter imagesFilter];
     }
-    else { // RNImagePickerTargetLibrarySingleImage
-      [self checkPhotosPermissions:^(BOOL granted) {
-        if (!granted) {
-          self.callback(@[@{@"error": @"Photo library permissions not granted"}]);
-          return;
-        }
 
-        showPickerViewController();
-      }];
-    }
-}
+    PHPickerViewController *pickerViewController = [[PHPickerViewController alloc] initWithConfiguration:configuration];
+    pickerViewController.delegate = self;
 
-- (NSString * _Nullable)originalFilenameForAsset:(PHAsset * _Nullable)asset assetType:(PHAssetResourceType)type {
-    if (!asset) { return nil; }
+    dispatch_async(dispatch_get_main_queue(), ^{
+        [RCTPresentedViewController() presentViewController:pickerViewController animated:YES completion:nil];
+    });
+}
 
-    PHAssetResource *originalResource;
-    // Get the underlying resources for the PHAsset (PhotoKit)
-    NSArray<PHAssetResource *> *pickedAssetResources = [PHAssetResource assetResourcesForAsset:asset];
+#pragma mark - PHPickerViewControllerDelegate (library)
 
-    // Find the original resource (underlying image) for the asset, which has the desired filename
-    for (PHAssetResource *resource in pickedAssetResources) {
-        if (resource.type == type) {
-            originalResource = resource;
+- (void)picker:(PHPickerViewController *)picker didFinishPicking:(NSArray<PHPickerResult *> *)results
+{
+    NSDictionary *options = self.options;
+    [picker dismissViewControllerAnimated:YES completion:^{
+        PHPickerResult *result = results.firstObject;
+        if (!result) {
+            [self sendResponse:@{@"didCancel": @YES}];
+            return;
         }
+        [self handlePickerResult:result options:options];
+    }];
+}
+
+- (void)handlePickerResult:(PHPickerResult *)result options:(NSDictionary *)options
+{
+    NSItemProvider *provider = result.itemProvider;
+    NSString *mediaType = [ImagePickerManager stringValue:options[@"mediaType"]];
+
+    BOOL isImage = [provider hasItemConformingToTypeIdentifier:UTTypeImage.identifier];
+    BOOL isMovie = [provider hasItemConformingToTypeIdentifier:UTTypeMovie.identifier];
+    BOOL treatAsVideo = isMovie && (!isImage || [mediaType isEqualToString:@"video"]);
+
+    if (!isImage && !isMovie) {
+        [self sendResponse:@{@"error": @"Unsupported media type"}];
+        return;
     }
 
-    return originalResource.originalFilename;
+    if (treatAsVideo) {
+        [provider loadFileRepresentationForTypeIdentifier:UTTypeMovie.identifier completionHandler:^(NSURL * _Nullable url, NSError * _Nullable error) {
+            // The file at `url` is deleted once this handler returns, so copy it out synchronously.
+            [self handleLibraryVideoAtURL:url error:error assetIdentifier:result.assetIdentifier suggestedName:provider.suggestedName options:options];
+        }];
+        return;
+    }
+
+    BOOL isGIF = [provider hasItemConformingToTypeIdentifier:UTTypeGIF.identifier];
+    NSString *typeIdentifier = isGIF ? UTTypeGIF.identifier : UTTypeImage.identifier;
+    [provider loadFileRepresentationForTypeIdentifier:typeIdentifier completionHandler:^(NSURL * _Nullable url, NSError * _Nullable error) {
+        NSData *data = url ? [NSData dataWithContentsOfURL:url] : nil;
+        if (!data) {
+            [self sendResponse:@{@"error": error.localizedDescription ?: @"Could not read photo"}];
+            return;
+        }
+        NSString *fileName = [self fileNameFromSuggestedName:provider.suggestedName extension:url.pathExtension];
+        [self handleLibraryImageData:data isGIF:isGIF assetIdentifier:result.assetIdentifier fileName:fileName options:options];
+    }];
 }
 
-- (void)imagePickerController:(UIImagePickerController *)picker didFinishPickingMediaWithInfo:(NSDictionary<NSString *,id> *)info
+- (void)handleLibraryImageData:(NSData *)data
+                         isGIF:(BOOL)isGIF
+               assetIdentifier:(NSString *)assetIdentifier
+                      fileName:(NSString *)fileName
+                       options:(NSDictionary *)options
 {
-    dispatch_block_t dismissCompletionBlock = ^{
+    UIImage *image = [UIImage imageWithData:data];
+    if (!image) {
+        [self sendResponse:@{@"error": @"Could not read photo"}];
+        return;
+    }
 
-        NSURL *imageURL = [info valueForKey:UIImagePickerControllerReferenceURL];
-        NSString *mediaType = [info objectForKey:UIImagePickerControllerMediaType];
+    NSDictionary *properties = [ImagePickerManager imagePropertiesFromData:data];
+    PHAsset *asset = [ImagePickerManager fetchAssetWithIdentifier:assetIdentifier];
 
-        NSString *fileName;
-        if ([mediaType isEqualToString:(NSString *)kUTTypeImage]) {
-            NSString *tempFileName = [[NSUUID UUID] UUIDString];
-            if (imageURL && [[imageURL absoluteString] rangeOfString:@"ext=GIF"].location != NSNotFound) {
-                fileName = [tempFileName stringByAppendingString:@".gif"];
-            }
-            else if ([[self.options objectForKey:@"imageFileType"] isEqualToString:@"png"]) {
-                fileName = [tempFileName stringByAppendingString:@".png"];
-            }
-            else {
-                fileName = [tempFileName stringByAppendingString:@".jpg"];
-            }
-        }
-        else {
-            NSURL *videoURL = info[UIImagePickerControllerMediaURL];
-            fileName = videoURL.lastPathComponent;
-        }
+    NSString *error = nil;
+    NSMutableDictionary *response;
+    if (isGIF) {
+        // GIFs break when resized, so pass the original bytes through untouched.
+        response = [self writeGIFData:data image:image options:options error:&error];
+    } else {
+        response = [self writeImage:image options:options error:&error];
+    }
+    if (!response) {
+        [self sendResponse:@{@"error": error ?: @"Could not save photo"}];
+        return;
+    }
 
-        // We default to path to the temporary directory
-        NSString *path = [[NSTemporaryDirectory()stringByStandardizingPath] stringByAppendingPathComponent:fileName];
-
-        // If storage options are provided, we use the documents directory which is persisted
-        if ([self.options objectForKey:@"storageOptions"] && [[self.options objectForKey:@"storageOptions"] isKindOfClass:[NSDictionary class]]) {
-            NSDictionary *storageOptions = [self.options objectForKey:@"storageOptions"];
-
-            NSArray *paths = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES);
-            NSString *documentsDirectory = [paths objectAtIndex:0];
-            path = [documentsDirectory stringByAppendingPathComponent:fileName];
-
-            // Creates documents subdirectory, if provided
-            if ([storageOptions objectForKey:@"path"]) {
-                NSString *newPath = [documentsDirectory stringByAppendingPathComponent:[storageOptions objectForKey:@"path"]];
-                NSError *error;
-                [[NSFileManager defaultManager] createDirectoryAtPath:newPath withIntermediateDirectories:YES attributes:nil error:&error];
-                if (error) {
-                    NSLog(@"Error creating documents subdirectory: %@", error);
-                    self.callback(@[@{@"error": error.localizedFailureReason}]);
-                    return;
-                }
-                else {
-                    path = [newPath stringByAppendingPathComponent:fileName];
-                }
-            }
-        }
+    // Location: prefer the file's own EXIF GPS, then fall back to the PHAsset.
+    CLLocation *location = [ImagePickerManager locationFromImageProperties:properties] ?: asset.location;
+    [ImagePickerManager applyLocation:location toResponse:response];
 
-        // Create the response object
-        self.response = [[NSMutableDictionary alloc] init];
+    NSDate *creationDate = [ImagePickerManager dateFromImageProperties:properties] ?: asset.creationDate;
+    if (creationDate) {
+        response[@"timestamp"] = [[ImagePickerManager ISO8601DateFormatter] stringFromDate:creationDate];
+    }
 
-        if ([mediaType isEqualToString:(NSString *)kUTTypeImage]) { // PHOTOS
-            UIImage *originalImage;
-            if ([[self.options objectForKey:@"allowsEditing"] boolValue]) {
-                originalImage = [info objectForKey:UIImagePickerControllerEditedImage];
-            }
-            else {
-                originalImage = [info objectForKey:UIImagePickerControllerOriginalImage];
-            }
-            
-            if (imageURL) {
-                PHAsset *pickedAsset;
-                if (@available(iOS 11.0, *)) {
-                  pickedAsset = [info objectForKey: UIImagePickerControllerPHAsset];
-                } else {
-                  pickedAsset = [PHAsset fetchAssetsWithALAssetURLs:@[imageURL] options:nil].lastObject;
-                }
-                
-                NSString *originalFilename = [self originalFilenameForAsset:pickedAsset assetType:PHAssetResourceTypePhoto];
-                self.response[@"fileName"] = originalFilename ?: [NSNull null];
-                if (pickedAsset.location) {
-                    self.response[@"latitude"] = @(pickedAsset.location.coordinate.latitude);
-                    self.response[@"longitude"] = @(pickedAsset.location.coordinate.longitude);
-                }
-                if (pickedAsset.creationDate) {
-                    self.response[@"timestamp"] = [[ImagePickerManager ISO8601DateFormatter] stringFromDate:pickedAsset.creationDate];
-                }
-            }
+    // fileName being present signals "picked from the library" (vs. a fresh camera capture) to callers.
+    NSString *originalFilename = [self originalFilenameForAsset:asset assetType:PHAssetResourceTypePhoto] ?: fileName;
+    response[@"fileName"] = originalFilename ?: [NSNull null];
+    if (asset) {
+        response[@"origURL"] = [@"ph://" stringByAppendingString:asset.localIdentifier];
+    } else if (assetIdentifier) {
+        response[@"origURL"] = [@"ph://" stringByAppendingString:assetIdentifier];
+    }
 
-            // GIFs break when resized, so we handle them differently
-            if (imageURL && [[imageURL absoluteString] rangeOfString:@"ext=GIF"].location != NSNotFound) {
-                ALAssetsLibrary* assetsLibrary = [[ALAssetsLibrary alloc] init];
-                [assetsLibrary assetForURL:imageURL resultBlock:^(ALAsset *asset) {
-                    ALAssetRepresentation *rep = [asset defaultRepresentation];
-                    const NSUInteger repSize = (NSUInteger)[rep size];
-                    Byte *buffer = (Byte*)malloc(repSize);
-                    NSUInteger buffered = [rep getBytes:buffer fromOffset:0.0 length:repSize error:nil];
-                    NSData *data = [NSData dataWithBytesNoCopy:buffer length:buffered freeWhenDone:YES];
-                    [data writeToFile:path atomically:YES];
-
-                    NSMutableDictionary *gifResponse = [[NSMutableDictionary alloc] init];
-                    [gifResponse setObject:@(originalImage.size.width) forKey:@"width"];
-                    [gifResponse setObject:@(originalImage.size.height) forKey:@"height"];
-
-                    [self populateResponse:gifResponse fromAsset:asset];
-                    
-                    BOOL vertical = (originalImage.size.width < originalImage.size.height) ? YES : NO;
-                    [gifResponse setObject:@(vertical) forKey:@"isVertical"];
-
-                    if (![[self.options objectForKey:@"noData"] boolValue]) {
-                        NSString *dataString = [data base64EncodedStringWithOptions:0];
-                        [gifResponse setObject:dataString forKey:@"data"];
-                    }
-
-                    NSURL *fileURL = [NSURL fileURLWithPath:path];
-                    [gifResponse setObject:[fileURL absoluteString] forKey:@"uri"];
-
-                    NSNumber *fileSizeValue = nil;
-                    NSError *fileSizeError = nil;
-                    [fileURL getResourceValue:&fileSizeValue forKey:NSURLFileSizeKey error:&fileSizeError];
-                    if (fileSizeValue){
-                        [gifResponse setObject:fileSizeValue forKey:@"fileSize"];
-                    }
-                    dispatch_async(dispatch_get_main_queue(), ^{
-                        self.callback(@[gifResponse]);
-                    });
-                } failureBlock:^(NSError *error) {
-                    dispatch_async(dispatch_get_main_queue(), ^{
-                        self.callback(@[@{@"error": error.localizedFailureReason}]);
-                    });
-                }];
-                return;
-            }
+    [self sendResponse:response];
+}
 
-            UIImage *editedImage = [self fixOrientation:originalImage];  // Rotate the image for upload to web
+- (void)handleLibraryVideoAtURL:(NSURL *)url
+                          error:(NSError *)loadError
+                assetIdentifier:(NSString *)assetIdentifier
+                  suggestedName:(NSString *)suggestedName
+                        options:(NSDictionary *)options
+{
+    if (!url) {
+        [self sendResponse:@{@"error": loadError.localizedDescription ?: @"Could not read video"}];
+        return;
+    }
 
-            // If needed, downscale image
-            float maxWidth = editedImage.size.width;
-            float maxHeight = editedImage.size.height;
-            if ([self.options valueForKey:@"maxWidth"]) {
-                maxWidth = [[self.options valueForKey:@"maxWidth"] floatValue];
-            }
-            if ([self.options valueForKey:@"maxHeight"]) {
-                maxHeight = [[self.options valueForKey:@"maxHeight"] floatValue];
-            }
-            editedImage = [self downscaleImageIfNecessary:editedImage maxWidth:maxWidth maxHeight:maxHeight];
+    NSString *error = nil;
+    NSString *extension = url.pathExtension.length > 0 ? url.pathExtension : @"mov";
+    NSString *path = [self destinationPathWithExtension:extension options:options error:&error];
+    if (!path) {
+        [self sendResponse:@{@"error": error}];
+        return;
+    }
 
-            NSData *data;
-            NSString *mimeType;
-            if ([[self.options objectForKey:@"imageFileType"] isEqualToString:@"png"]) {
-                data = UIImagePNGRepresentation(editedImage);
-                mimeType = @"image/png";
-            }
-            else {
-                data = UIImageJPEGRepresentation(editedImage, [[self.options valueForKey:@"quality"] floatValue]);
-                mimeType = @"image/jpeg";
-            }
-            [self.response setObject:mimeType forKey:@"type"];
-            [data writeToFile:path atomically:YES];
+    NSURL *destinationURL = [NSURL fileURLWithPath:path];
+    NSError *copyError = nil;
+    [[NSFileManager defaultManager] removeItemAtURL:destinationURL error:nil];
+    if (![[NSFileManager defaultManager] copyItemAtURL:url toURL:destinationURL error:&copyError]) {
+        [self sendResponse:@{@"error": copyError.localizedDescription ?: @"Could not save video"}];
+        return;
+    }
+    [self applySkipBackupIfNeeded:path options:options];
 
-            if (![[self.options objectForKey:@"noData"] boolValue]) {
-                NSString *dataString = [data base64EncodedStringWithOptions:0]; // base64 encoded image string
-                [self.response setObject:dataString forKey:@"data"];
-            }
+    NSMutableDictionary *response = [NSMutableDictionary dictionary];
+    response[@"uri"] = destinationURL.absoluteString;
 
-            BOOL vertical = (editedImage.size.width < editedImage.size.height) ? YES : NO;
-            [self.response setObject:@(vertical) forKey:@"isVertical"];
-            NSURL *fileURL = [NSURL fileURLWithPath:path];
-            NSString *filePath = [fileURL absoluteString];
-            [self.response setObject:filePath forKey:@"uri"];
+    PHAsset *asset = [ImagePickerManager fetchAssetWithIdentifier:assetIdentifier];
+    [ImagePickerManager applyLocation:asset.location toResponse:response];
+    if (asset.creationDate) {
+        response[@"timestamp"] = [[ImagePickerManager ISO8601DateFormatter] stringFromDate:asset.creationDate];
+    }
+    NSString *originalFilename = [self originalFilenameForAsset:asset assetType:PHAssetResourceTypeVideo]
+        ?: [self fileNameFromSuggestedName:suggestedName extension:url.pathExtension];
+    response[@"fileName"] = originalFilename ?: [NSNull null];
+    if (assetIdentifier) {
+        response[@"origURL"] = [@"ph://" stringByAppendingString:assetIdentifier];
+    }
 
-            // add ref to the original image
-            NSString *origURL = [imageURL absoluteString];
-            if (origURL) {
-              [self.response setObject:origURL forKey:@"origURL"];
-            }
+    [self sendResponse:response];
+}
 
-            NSNumber *fileSizeValue = nil;
-            NSError *fileSizeError = nil;
-            [fileURL getResourceValue:&fileSizeValue forKey:NSURLFileSizeKey error:&fileSizeError];
-            if (fileSizeValue){
-                [self.response setObject:fileSizeValue forKey:@"fileSize"];
-            }
+#pragma mark - UIImagePickerControllerDelegate (camera)
 
-            [self.response setObject:@(editedImage.size.width) forKey:@"width"];
-            [self.response setObject:@(editedImage.size.height) forKey:@"height"];
-
-            NSDictionary *storageOptions = [self.options objectForKey:@"storageOptions"];
-            if (storageOptions && [[storageOptions objectForKey:@"cameraRoll"] boolValue] == YES && self.picker.sourceType == UIImagePickerControllerSourceTypeCamera) {
-                ALAssetsLibrary *library = [[ALAssetsLibrary alloc] init];
-                if ([[storageOptions objectForKey:@"waitUntilSaved"] boolValue]) {
-                    [library writeImageToSavedPhotosAlbum:originalImage.CGImage metadata:[info valueForKey:UIImagePickerControllerMediaMetadata] completionBlock:^(NSURL *assetURL, NSError *error) {
-                        if (error) {
-                            NSLog(@"Error while saving picture into photo album");
-                        } else {
-                            // when the image has been saved in the photo album
-                            if (assetURL) {
-                                PHAsset *capturedAsset = [PHAsset fetchAssetsWithALAssetURLs:@[assetURL] options:nil].lastObject;
-                                NSString *originalFilename = [self originalFilenameForAsset:capturedAsset assetType:PHAssetResourceTypePhoto];
-                                self.response[@"fileName"] = originalFilename ?: [NSNull null];
-                                // This implementation will never have a location for the captured image, it needs to be added manually with CoreLocation code here.
-                                if (capturedAsset.creationDate) {
-                                    self.response[@"timestamp"] = [[ImagePickerManager ISO8601DateFormatter] stringFromDate:capturedAsset.creationDate];
-                                }
-                            }
-                            [self dispatchCallbackForUrl:assetURL withResponse:self.response];
-                        }
-                    }];
-                } else {
-                    [library writeImageToSavedPhotosAlbum:originalImage.CGImage metadata:[info valueForKey:UIImagePickerControllerMediaMetadata] completionBlock:nil];
-                }
-            }
-        }
-        else { // VIDEO
-            NSURL *videoRefURL = info[UIImagePickerControllerReferenceURL];
-            NSURL *videoURL = info[UIImagePickerControllerMediaURL];
-            NSURL *videoDestinationURL = [NSURL fileURLWithPath:path];
-
-            if (videoRefURL) {
-                PHAsset *pickedAsset = [PHAsset fetchAssetsWithALAssetURLs:@[videoRefURL] options:nil].lastObject;
-                NSString *originalFilename = [self originalFilenameForAsset:pickedAsset assetType:PHAssetResourceTypeVideo];
-                self.response[@"fileName"] = originalFilename ?: [NSNull null];
-                if (pickedAsset.location) {
-                    self.response[@"latitude"] = @(pickedAsset.location.coordinate.latitude);
-                    self.response[@"longitude"] = @(pickedAsset.location.coordinate.longitude);
-                }
-                if (pickedAsset.creationDate) {
-                    self.response[@"timestamp"] = [[ImagePickerManager ISO8601DateFormatter] stringFromDate:pickedAsset.creationDate];
-                }
+- (void)imagePickerController:(UIImagePickerController *)picker didFinishPickingMediaWithInfo:(NSDictionary<UIImagePickerControllerInfoKey, id> *)info
+{
+    NSDictionary *options = self.options;
+    [picker dismissViewControllerAnimated:YES completion:^{
+        // Encoding a full-resolution capture is slow; keep it off the main thread.
+        dispatch_async(dispatch_get_global_queue(QOS_CLASS_USER_INITIATED, 0), ^{
+            NSString *mediaType = info[UIImagePickerControllerMediaType];
+            if ([mediaType isEqualToString:UTTypeMovie.identifier]) {
+                [self handleCapturedVideoWithInfo:info options:options];
+            } else {
+                [self handleCapturedImageWithInfo:info options:options];
             }
+        });
+    }];
+}
 
-            if ([videoURL.URLByResolvingSymlinksInPath.path isEqualToString:videoDestinationURL.URLByResolvingSymlinksInPath.path] == NO) {
-                NSFileManager *fileManager = [NSFileManager defaultManager];
+- (void)imagePickerControllerDidCancel:(UIImagePickerController *)picker
+{
+    [picker dismissViewControllerAnimated:YES completion:^{
+        [self sendResponse:@{@"didCancel": @YES}];
+    }];
+}
 
-                // Delete file if it already exists
-                if ([fileManager fileExistsAtPath:videoDestinationURL.path]) {
-                    [fileManager removeItemAtURL:videoDestinationURL error:nil];
-                }
+- (void)handleCapturedImageWithInfo:(NSDictionary<UIImagePickerControllerInfoKey, id> *)info options:(NSDictionary *)options
+{
+    UIImage *originalImage = info[UIImagePickerControllerOriginalImage];
+    UIImage *image = originalImage;
+    if ([options[@"allowsEditing"] boolValue] && info[UIImagePickerControllerEditedImage]) {
+        image = info[UIImagePickerControllerEditedImage];
+    }
+    if (!image) {
+        [self sendResponse:@{@"error": @"Could not read photo"}];
+        return;
+    }
 
-                if (videoURL) { // Protect against reported crash
-                  NSError *error = nil;
-
-                  // If we have write access to the source file, move it. Otherwise use copy. 
-                  if ([fileManager isWritableFileAtPath:[videoURL path]]) {
-                    [fileManager moveItemAtURL:videoURL toURL:videoDestinationURL error:&error];
-                  } else {
-                    [fileManager copyItemAtURL:videoURL toURL:videoDestinationURL error:&error];
-                  }
-    
-                  if (error) {
-                      self.callback(@[@{@"error": error.localizedFailureReason}]);
-                      return;
-                  }
-                }
-            }
+    NSString *error = nil;
+    NSMutableDictionary *response = [self writeImage:image options:options error:&error];
+    if (!response) {
+        [self sendResponse:@{@"error": error ?: @"Could not save photo"}];
+        return;
+    }
 
-            [self.response setObject:videoDestinationURL.absoluteString forKey:@"uri"];
-            if (videoRefURL.absoluteString) {
-                [self.response setObject:videoRefURL.absoluteString forKey:@"origURL"];
-            }
+    // The camera's metadata normally has no GPS (UIImagePickerController doesn't geotag), in which
+    // case callers fall back to the device's current location. fileName is intentionally left unset
+    // for captures so callers can tell them apart from library picks.
+    NSDictionary *metadata = info[UIImagePickerControllerMediaMetadata];
+    [ImagePickerManager applyLocation:[ImagePickerManager locationFromImageProperties:metadata] toResponse:response];
+    NSDate *captureDate = [ImagePickerManager dateFromImageProperties:metadata];
+    if (captureDate) {
+        response[@"timestamp"] = [[ImagePickerManager ISO8601DateFormatter] stringFromDate:captureDate];
+    }
 
-            NSDictionary *storageOptions = [self.options objectForKey:@"storageOptions"];
-            if (storageOptions && [[storageOptions objectForKey:@"cameraRoll"] boolValue] == YES && self.picker.sourceType == UIImagePickerControllerSourceTypeCamera) {
-                ALAssetsLibrary *library = [[ALAssetsLibrary alloc] init];
-                [library writeVideoAtPathToSavedPhotosAlbum:videoDestinationURL completionBlock:^(NSURL *assetURL, NSError *error) {
-                    if (error) {
-                        dispatch_async(dispatch_get_main_queue(), ^{
-                            self.callback(@[@{@"error": error.localizedFailureReason}]);
-                        });
-                        return;
-                    } else {
-                        NSLog(@"Save video succeed.");
-                        if ([[storageOptions objectForKey:@"waitUntilSaved"] boolValue]) {
-                            if (assetURL) {
-                                PHAsset *capturedAsset = [PHAsset fetchAssetsWithALAssetURLs:@[assetURL] options:nil].lastObject;
-                                NSString *originalFilename = [self originalFilenameForAsset:capturedAsset assetType:PHAssetResourceTypeVideo];
-                                self.response[@"fileName"] = originalFilename ?: [NSNull null];
-                                // This implementation will never have a location for the captured image, it needs to be added manually with CoreLocation code here.
-                                if (capturedAsset.creationDate) {
-                                    self.response[@"timestamp"] = [[ImagePickerManager ISO8601DateFormatter] stringFromDate:capturedAsset.creationDate];
-                                }
-                                [self dispatchCallbackForUrl:assetURL withResponse:self.response];
-                            } else {
-                                [self dispatchCallbackForUrl:[info valueForKey:UIImagePickerControllerReferenceURL] withResponse:self.response];
-                            }
-
-
-                        }
-                    }
-                }];
-            }
+    NSDictionary *storageOptions = [ImagePickerManager storageOptionsFrom:options];
+    if (![storageOptions[@"cameraRoll"] boolValue]) {
+        [self sendResponse:response];
+        return;
+    }
+
+    NSData *photoData = [ImagePickerManager JPEGDataForImage:originalImage metadata:metadata];
+    BOOL waitUntilSaved = [storageOptions[@"waitUntilSaved"] boolValue];
+    [self saveToCameraRollPhotoData:photoData videoURL:nil completion:^(PHAsset *asset, NSError *saveError) {
+        if (saveError) {
+            NSLog(@"ImagePickerManager: error saving photo to camera roll: %@", saveError);
+        }
+        if (waitUntilSaved) {
+            [self applySavedAsset:asset assetType:PHAssetResourceTypePhoto toResponse:response];
+            [self sendResponse:response];
         }
+    }];
+    if (!waitUntilSaved) {
+        [self sendResponse:response];
+    }
+}
 
-        // If storage options are provided, check the skipBackup flag
-        if ([self.options objectForKey:@"storageOptions"] && [[self.options objectForKey:@"storageOptions"] isKindOfClass:[NSDictionary class]]) {
-            NSDictionary *storageOptions = [self.options objectForKey:@"storageOptions"];
+- (void)handleCapturedVideoWithInfo:(NSDictionary<UIImagePickerControllerInfoKey, id> *)info options:(NSDictionary *)options
+{
+    NSURL *videoURL = info[UIImagePickerControllerMediaURL];
+    if (!videoURL) {
+        [self sendResponse:@{@"error": @"Could not read video"}];
+        return;
+    }
 
-            if ([[storageOptions objectForKey:@"skipBackup"] boolValue]) {
-                [self addSkipBackupAttributeToItemAtPath:path]; // Don't back up the file to iCloud
-            }
+    NSString *error = nil;
+    NSString *extension = videoURL.pathExtension.length > 0 ? videoURL.pathExtension : @"mov";
+    NSString *path = [self destinationPathWithExtension:extension options:options error:&error];
+    if (!path) {
+        [self sendResponse:@{@"error": error}];
+        return;
+    }
+    NSURL *destinationURL = [NSURL fileURLWithPath:path];
+
+    NSFileManager *fileManager = [NSFileManager defaultManager];
+    [fileManager removeItemAtURL:destinationURL error:nil];
+    NSError *moveError = nil;
+    BOOL moved;
+    if ([fileManager isWritableFileAtPath:videoURL.path]) {
+        moved = [fileManager moveItemAtURL:videoURL toURL:destinationURL error:&moveError];
+    } else {
+        moved = [fileManager copyItemAtURL:videoURL toURL:destinationURL error:&moveError];
+    }
+    if (!moved) {
+        [self sendResponse:@{@"error": moveError.localizedDescription ?: @"Could not save video"}];
+        return;
+    }
+    [self applySkipBackupIfNeeded:path options:options];
 
-            if ([[storageOptions objectForKey:@"waitUntilSaved"] boolValue] == NO ||
-                [[storageOptions objectForKey:@"cameraRoll"] boolValue] == NO ||
-                self.picker.sourceType != UIImagePickerControllerSourceTypeCamera)
-            {
-                [self dispatchCallbackForUrl:[info valueForKey:UIImagePickerControllerReferenceURL] withResponse:self.response];
-            }
+    NSMutableDictionary *response = [NSMutableDictionary dictionary];
+    response[@"uri"] = destinationURL.absoluteString;
+
+    NSDictionary *storageOptions = [ImagePickerManager storageOptionsFrom:options];
+    if (![storageOptions[@"cameraRoll"] boolValue]) {
+        [self sendResponse:response];
+        return;
+    }
+
+    BOOL waitUntilSaved = [storageOptions[@"waitUntilSaved"] boolValue];
+    [self saveToCameraRollPhotoData:nil videoURL:destinationURL completion:^(PHAsset *asset, NSError *saveError) {
+        if (saveError) {
+            NSLog(@"ImagePickerManager: error saving video to camera roll: %@", saveError);
         }
-        else {
-            [self dispatchCallbackForUrl:[info valueForKey:UIImagePickerControllerReferenceURL] withResponse:self.response];
+        if (waitUntilSaved) {
+            [self applySavedAsset:asset assetType:PHAssetResourceTypeVideo toResponse:response];
+            [self sendResponse:response];
         }
-    };
+    }];
+    if (!waitUntilSaved) {
+        [self sendResponse:response];
+    }
+}
 
-    dispatch_async(dispatch_get_main_queue(), ^{
-        [picker dismissViewControllerAnimated:YES completion:dismissCompletionBlock];
-    });
+#pragma mark - Camera roll
+
+- (void)saveToCameraRollPhotoData:(NSData *)photoData
+                         videoURL:(NSURL *)videoURL
+                       completion:(void (^)(PHAsset *asset, NSError *error))completion
+{
+    __block NSString *localIdentifier = nil;
+    [[PHPhotoLibrary sharedPhotoLibrary] performChanges:^{
+        PHAssetCreationRequest *request = [PHAssetCreationRequest creationRequestForAsset];
+        if (photoData) {
+            [request addResourceWithType:PHAssetResourceTypePhoto data:photoData options:nil];
+        } else {
+            [request addResourceWithType:PHAssetResourceTypeVideo fileURL:videoURL options:nil];
+        }
+        localIdentifier = request.placeholderForCreatedAsset.localIdentifier;
+    } completionHandler:^(BOOL success, NSError * _Nullable error) {
+        // Fetching back requires read access; with add-only access this is simply nil.
+        PHAsset *asset = success ? [ImagePickerManager fetchAssetWithIdentifier:localIdentifier] : nil;
+        completion(asset, error);
+    }];
 }
 
-- (void) populateResponse:(NSMutableDictionary *) response fromAsset:(ALAsset *) asset {
-    CLLocation * location = [asset valueForProperty:ALAssetPropertyLocation];
-    if(location){
-        response[@"latitude"] = @(location.coordinate.latitude);
-        response[@"longitude"] = @(location.coordinate.longitude);
+- (void)applySavedAsset:(PHAsset *)asset assetType:(PHAssetResourceType)type toResponse:(NSMutableDictionary *)response
+{
+    if (!asset) {
+        return;
+    }
+    NSString *originalFilename = [self originalFilenameForAsset:asset assetType:type];
+    response[@"fileName"] = originalFilename ?: [NSNull null];
+    if (asset.creationDate) {
+        response[@"timestamp"] = [[ImagePickerManager ISO8601DateFormatter] stringFromDate:asset.creationDate];
     }
+    response[@"origURL"] = [@"ph://" stringByAppendingString:asset.localIdentifier];
 }
 
-- (void) dispatchCallbackForUrl: (NSURL *) url withResponse: (NSMutableDictionary *)response {
-    if(!url){
-        dispatch_async(dispatch_get_main_queue(), ^{
-            self.callback(@[response]);
-        });
+#pragma mark - Writing images
+
+- (NSMutableDictionary *)writeImage:(UIImage *)image options:(NSDictionary *)options error:(NSString **)error
+{
+    BOOL png = [[ImagePickerManager stringValue:options[@"imageFileType"]] isEqualToString:@"png"];
+    NSString *path = [self destinationPathWithExtension:(png ? @"png" : @"jpg") options:options error:error];
+    if (!path) {
+        return nil;
     }
-    if(response && !response[@"latitude"] && !response[@"longitude"]){
-        ALAssetsLibrary * library = [[ALAssetsLibrary alloc] init];
-        [library assetForURL:url resultBlock:^(ALAsset * asset){
-            [self populateResponse:response fromAsset:asset];
-            dispatch_async(dispatch_get_main_queue(), ^{
-                self.callback(@[response]);
-            });
-        } failureBlock:^(NSError * error){
-            dispatch_async(dispatch_get_main_queue(), ^{
-                self.callback(@[response]);
-            });
-        }];
+
+    UIImage *editedImage = [self fixOrientation:image];  // Rotate the image for upload to web
+
+    // If needed, downscale image
+    CGFloat maxWidth = editedImage.size.width;
+    CGFloat maxHeight = editedImage.size.height;
+    if ([options[@"maxWidth"] isKindOfClass:[NSNumber class]]) {
+        maxWidth = [options[@"maxWidth"] floatValue];
+    }
+    if ([options[@"maxHeight"] isKindOfClass:[NSNumber class]]) {
+        maxHeight = [options[@"maxHeight"] floatValue];
+    }
+    editedImage = [self downscaleImageIfNecessary:editedImage maxWidth:maxWidth maxHeight:maxHeight];
+
+    NSData *data;
+    NSString *mimeType;
+    if (png) {
+        data = UIImagePNGRepresentation(editedImage);
+        mimeType = @"image/png";
     } else {
-        dispatch_async(dispatch_get_main_queue(), ^{
-            self.callback(@[response]);
-        });
+        CGFloat quality = [options[@"quality"] isKindOfClass:[NSNumber class]] ? [options[@"quality"] floatValue] : 1.0;
+        data = UIImageJPEGRepresentation(editedImage, quality);
+        mimeType = @"image/jpeg";
+    }
+    if (!data || ![data writeToFile:path atomically:YES]) {
+        if (error) { *error = @"Could not save photo"; }
+        return nil;
+    }
+    [self applySkipBackupIfNeeded:path options:options];
+
+    NSMutableDictionary *response = [NSMutableDictionary dictionary];
+    response[@"type"] = mimeType;
+    if (![options[@"noData"] boolValue]) {
+        response[@"data"] = [data base64EncodedStringWithOptions:0];
     }
+    response[@"isVertical"] = @(editedImage.size.width < editedImage.size.height);
+    response[@"width"] = @(editedImage.size.width);
+    response[@"height"] = @(editedImage.size.height);
+    [self applyFileURL:[NSURL fileURLWithPath:path] toResponse:response];
+    return response;
 }
 
-- (void)imagePickerControllerDidCancel:(UIImagePickerController *)picker
+- (NSMutableDictionary *)writeGIFData:(NSData *)data image:(UIImage *)image options:(NSDictionary *)options error:(NSString **)error
+{
+    NSString *path = [self destinationPathWithExtension:@"gif" options:options error:error];
+    if (!path) {
+        return nil;
+    }
+    if (![data writeToFile:path atomically:YES]) {
+        if (error) { *error = @"Could not save photo"; }
+        return nil;
+    }
+    [self applySkipBackupIfNeeded:path options:options];
+
+    NSMutableDictionary *response = [NSMutableDictionary dictionary];
+    response[@"type"] = @"image/gif";
+    if (![options[@"noData"] boolValue]) {
+        response[@"data"] = [data base64EncodedStringWithOptions:0];
+    }
+    response[@"isVertical"] = @(image.size.width < image.size.height);
+    response[@"width"] = @(image.size.width);
+    response[@"height"] = @(image.size.height);
+    [self applyFileURL:[NSURL fileURLWithPath:path] toResponse:response];
+    return response;
+}
+
+- (void)applyFileURL:(NSURL *)fileURL toResponse:(NSMutableDictionary *)response
+{
+    response[@"uri"] = fileURL.absoluteString;
+    NSNumber *fileSizeValue = nil;
+    [fileURL getResourceValue:&fileSizeValue forKey:NSURLFileSizeKey error:nil];
+    if (fileSizeValue) {
+        response[@"fileSize"] = fileSizeValue;
+    }
+}
+
+// Temporary directory by default; the (persisted) documents directory when storageOptions are given.
+- (NSString *)destinationPathWithExtension:(NSString *)extension options:(NSDictionary *)options error:(NSString **)error
+{
+    NSString *fileName = [[[NSUUID UUID] UUIDString] stringByAppendingPathExtension:extension];
+    NSString *directory = [NSTemporaryDirectory() stringByStandardizingPath];
+
+    NSDictionary *storageOptions = [ImagePickerManager storageOptionsFrom:options];
+    if (storageOptions) {
+        directory = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES).firstObject;
+        NSString *subpath = [ImagePickerManager stringValue:storageOptions[@"path"]];
+        if (subpath.length > 0) {
+            directory = [directory stringByAppendingPathComponent:subpath];
+            NSError *createError = nil;
+            if (![[NSFileManager defaultManager] createDirectoryAtPath:directory withIntermediateDirectories:YES attributes:nil error:&createError]) {
+                NSLog(@"Error creating documents subdirectory: %@", createError);
+                if (error) { *error = createError.localizedDescription ?: @"Could not create directory"; }
+                return nil;
+            }
+        }
+    }
+    return [directory stringByAppendingPathComponent:fileName];
+}
+
+- (void)applySkipBackupIfNeeded:(NSString *)path options:(NSDictionary *)options
+{
+    if ([[ImagePickerManager storageOptionsFrom:options][@"skipBackup"] boolValue]) {
+        [self addSkipBackupAttributeToItemAtPath:path]; // Don't back up the file to iCloud
+    }
+}
+
+#pragma mark - Responses
+
+// RCTResponseSenderBlock may only be invoked once; drop the callback as soon as it's used.
+- (void)sendResponse:(NSDictionary *)response
 {
     dispatch_async(dispatch_get_main_queue(), ^{
-        [picker dismissViewControllerAnimated:YES completion:^{
-            self.callback(@[@{@"didCancel": @YES}]);
-        }];
+        RCTResponseSenderBlock callback = self.callback;
+        self.callback = nil;
+        if (callback) {
+            callback(@[response]);
+        }
     });
 }
 
-#pragma mark - Helpers
+- (NSString *)stringOption:(NSString *)key
+{
+    return [ImagePickerManager stringValue:self.options[key]];
+}
+
+- (NSString *)fileNameFromSuggestedName:(NSString *)suggestedName extension:(NSString *)extension
+{
+    if (suggestedName.length == 0) {
+        return nil;
+    }
+    if (extension.length == 0 || suggestedName.pathExtension.length > 0) {
+        return suggestedName;
+    }
+    return [suggestedName stringByAppendingPathExtension:extension];
+}
+
+- (NSString * _Nullable)originalFilenameForAsset:(PHAsset * _Nullable)asset assetType:(PHAssetResourceType)type {
+    if (!asset) { return nil; }
+
+    PHAssetResource *originalResource;
+    // Get the underlying resources for the PHAsset (PhotoKit)
+    NSArray<PHAssetResource *> *pickedAssetResources = [PHAssetResource assetResourcesForAsset:asset];
+
+    // Find the original resource (underlying image) for the asset, which has the desired filename
+    for (PHAssetResource *resource in pickedAssetResources) {
+        if (resource.type == type) {
+            originalResource = resource;
+        }
+    }
+
+    return originalResource.originalFilename;
+}
+
+#pragma mark - Permissions
 
 - (void)checkCameraPermissions:(void(^)(BOOL granted))callback
 {
     AVAuthorizationStatus status = [AVCaptureDevice authorizationStatusForMediaType:AVMediaTypeVideo];
     if (status == AVAuthorizationStatusAuthorized) {
         callback(YES);
-        return;
-    } else if (status == AVAuthorizationStatusNotDetermined){
+    } else if (status == AVAuthorizationStatusNotDetermined) {
         [AVCaptureDevice requestAccessForMediaType:AVMediaTypeVideo completionHandler:^(BOOL granted) {
             callback(granted);
-            return;
         }];
     } else {
         callback(NO);
     }
 }
 
-- (void)checkPhotosPermissions:(void(^)(BOOL granted))callback
-{
-    PHAuthorizationStatus status = [PHPhotoLibrary authorizationStatus];
-    if (status == PHAuthorizationStatusAuthorized) {
-        callback(YES);
-        return;
-    } else if (status == PHAuthorizationStatusNotDetermined) {
-        [PHPhotoLibrary requestAuthorization:^(PHAuthorizationStatus status) {
-            if (status == PHAuthorizationStatusAuthorized) {
-                callback(YES);
-                return;
-            }
-            else {
-                callback(NO);
-                return;
-            }
-        }];
-    }
-    else {
-        callback(NO);
-    }
-}
+#pragma mark - Image helpers
 
-- (UIImage*)downscaleImageIfNecessary:(UIImage*)image maxWidth:(float)maxWidth maxHeight:(float)maxHeight
+- (UIImage*)downscaleImageIfNecessary:(UIImage*)image maxWidth:(CGFloat)maxWidth maxHeight:(CGFloat)maxHeight
 {
-    UIImage* newImage = image;
-
     // Nothing to do here
     if (image.size.width <= maxWidth && image.size.height <= maxHeight) {
-        return newImage;
+        return image;
     }
 
     CGSize scaledSize = CGSizeMake(image.size.width, image.size.height);
@@ -648,18 +751,21 @@ RCT_EXPORT_METHOD(showImagePicker:(NSDictionary *)options callback:(RCTResponseS
         scaledSize = CGSizeMake((maxHeight / scaledSize.height) * scaledSize.width, maxHeight);
     }
 
-    // If the pixels are floats, it causes a white line in iOS8 and probably other versions too
+    // If the pixels are floats, it causes a white line
     scaledSize.width = (int)scaledSize.width;
     scaledSize.height = (int)scaledSize.height;
 
-    UIGraphicsBeginImageContext(scaledSize); // this will resize
-    [image drawInRect:CGRectMake(0, 0, scaledSize.width, scaledSize.height)];
-    newImage = UIGraphicsGetImageFromCurrentImageContext();
+    // fixOrientation produces a scale-1 image, so points == pixels; render at scale 1 to match.
+    UIGraphicsImageRendererFormat *format = [UIGraphicsImageRendererFormat preferredFormat];
+    format.scale = 1;
+    UIGraphicsImageRenderer *renderer = [[UIGraphicsImageRenderer alloc] initWithSize:scaledSize format:format];
+    UIImage *newImage = [renderer imageWithActions:^(UIGraphicsImageRendererContext * _Nonnull context) {
+        [image drawInRect:CGRectMake(0, 0, scaledSize.width, scaledSize.height)];
+    }];
     if (newImage == nil) {
         NSLog(@"could not scale image");
+        return image;
     }
-    UIGraphicsEndImageContext();
-
     return newImage;
 }
 
@@ -712,6 +818,9 @@ RCT_EXPORT_METHOD(showImagePicker:(NSDictionary *)options callback:(RCTResponseS
     }
 
     CGContextRef ctx = CGBitmapContextCreate(NULL, srcImg.size.width, srcImg.size.height, CGImageGetBitsPerComponent(srcImg.CGImage), 0, CGImageGetColorSpace(srcImg.CGImage), CGImageGetBitmapInfo(srcImg.CGImage));
+    if (!ctx) {
+        return srcImg;
+    }
     CGContextConcatCTM(ctx, transform);
     switch (srcImg.imageOrientation) {
         case UIImageOrientationLeft:
@@ -754,6 +863,113 @@ RCT_EXPORT_METHOD(showImagePicker:(NSDictionary *)options callback:(RCTResponseS
 
 #pragma mark - Class Methods
 
++ (NSString *)stringValue:(id)value
+{
+    return [value isKindOfClass:[NSString class]] ? value : nil;
+}
+
++ (NSDictionary *)storageOptionsFrom:(NSDictionary *)options
+{
+    id storageOptions = options[@"storageOptions"];
+    return [storageOptions isKindOfClass:[NSDictionary class]] ? storageOptions : nil;
+}
+
+// Only touches PhotoKit when the app already has read access, so this never triggers a permission prompt.
++ (PHAsset *)fetchAssetWithIdentifier:(NSString *)identifier
+{
+    if (identifier.length == 0) {
+        return nil;
+    }
+    PHAuthorizationStatus status = [PHPhotoLibrary authorizationStatusForAccessLevel:PHAccessLevelReadWrite];
+    if (status != PHAuthorizationStatusAuthorized && status != PHAuthorizationStatusLimited) {
+        return nil;
+    }
+    return [PHAsset fetchAssetsWithLocalIdentifiers:@[identifier] options:nil].firstObject;
+}
+
++ (NSDictionary *)imagePropertiesFromData:(NSData *)data
+{
+    CGImageSourceRef source = CGImageSourceCreateWithData((__bridge CFDataRef)data, NULL);
+    if (!source) {
+        return nil;
+    }
+    NSDictionary *properties = (__bridge_transfer NSDictionary *)CGImageSourceCopyPropertiesAtIndex(source, 0, NULL);
+    CFRelease(source);
+    return properties;
+}
+
++ (CLLocation *)locationFromImageProperties:(NSDictionary *)properties
+{
+    NSDictionary *gps = properties[(NSString *)kCGImagePropertyGPSDictionary];
+    if (![gps isKindOfClass:[NSDictionary class]]) {
+        return nil;
+    }
+    NSNumber *latitude = gps[(NSString *)kCGImagePropertyGPSLatitude];
+    NSNumber *longitude = gps[(NSString *)kCGImagePropertyGPSLongitude];
+    if (![latitude isKindOfClass:[NSNumber class]] || ![longitude isKindOfClass:[NSNumber class]]) {
+        return nil;
+    }
+    double lat = latitude.doubleValue;
+    double lon = longitude.doubleValue;
+    if ([gps[(NSString *)kCGImagePropertyGPSLatitudeRef] isEqual:@"S"]) { lat = -lat; }
+    if ([gps[(NSString *)kCGImagePropertyGPSLongitudeRef] isEqual:@"W"]) { lon = -lon; }
+    if (lat == 0 && lon == 0) {
+        return nil;
+    }
+    return [[CLLocation alloc] initWithLatitude:lat longitude:lon];
+}
+
++ (void)applyLocation:(CLLocation *)location toResponse:(NSMutableDictionary *)response
+{
+    if (!location) {
+        return;
+    }
+    response[@"latitude"] = @(location.coordinate.latitude);
+    response[@"longitude"] = @(location.coordinate.longitude);
+}
+
++ (NSDate *)dateFromImageProperties:(NSDictionary *)properties
+{
+    NSDictionary *exif = properties[(NSString *)kCGImagePropertyExifDictionary];
+    if (![exif isKindOfClass:[NSDictionary class]]) {
+        return nil;
+    }
+    NSString *dateString = [self stringValue:exif[(NSString *)kCGImagePropertyExifDateTimeOriginal]];
+    if (dateString.length == 0) {
+        return nil;
+    }
+    NSString *offset = [self stringValue:exif[(NSString *)kCGImagePropertyExifOffsetTimeOriginal]];
+
+    NSDateFormatter *formatter = [[NSDateFormatter alloc] init];
+    formatter.locale = [NSLocale localeWithLocaleIdentifier:@"en_US_POSIX"];
+    if (offset.length > 0) {
+        formatter.dateFormat = @"yyyy:MM:dd HH:mm:ssxxx";
+        return [formatter dateFromString:[dateString stringByAppendingString:offset]];
+    }
+    // No offset recorded: EXIF times are local to where the photo was taken; assume the device's zone.
+    formatter.dateFormat = @"yyyy:MM:dd HH:mm:ss";
+    formatter.timeZone = [NSTimeZone localTimeZone];
+    return [formatter dateFromString:dateString];
+}
+
++ (NSData *)JPEGDataForImage:(UIImage *)image metadata:(NSDictionary *)metadata
+{
+    if (!image.CGImage) {
+        return UIImageJPEGRepresentation(image, 0.9);
+    }
+    NSMutableData *data = [NSMutableData data];
+    CGImageDestinationRef destination = CGImageDestinationCreateWithData((__bridge CFMutableDataRef)data, (__bridge CFStringRef)UTTypeJPEG.identifier, 1, NULL);
+    if (!destination) {
+        return UIImageJPEGRepresentation(image, 0.9);
+    }
+    NSMutableDictionary *properties = [metadata mutableCopy] ?: [NSMutableDictionary dictionary];
+    properties[(NSString *)kCGImageDestinationLossyCompressionQuality] = @0.9;
+    CGImageDestinationAddImage(destination, image.CGImage, (__bridge CFDictionaryRef)properties);
+    BOOL ok = CGImageDestinationFinalize(destination);
+    CFRelease(destination);
+    return ok ? data : UIImageJPEGRepresentation(image, 0.9);
+}
+
 + (NSDateFormatter * _Nonnull)ISO8601DateFormatter {
     static NSDateFormatter *ISO8601DateFormatter;
     static dispatch_once_t onceToken;