From 739cb20679e08444b93de220266ebbd7fabd01be Mon Sep 17 00:00:00 2001 From: zher52 Date: Mon, 1 Jun 2020 16:00:56 +0800 Subject: [PATCH] =?UTF-8?q?ios=E5=90=88=E5=B9=B6cordova=20camera=20?= =?UTF-8?q?=E7=9A=84=E5=8F=96=E7=9B=B8=E5=86=8C=E7=85=A7=E7=89=87=E7=9A=84?= =?UTF-8?q?=E6=96=B9=E6=B3=95?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- plugin.xml | 3 + src/ios/classes/CustomCamera.h | 63 +++- src/ios/classes/CustomCamera.m | 509 ++++++++++++++++++++++++++++++--- 3 files changed, 542 insertions(+), 33 deletions(-) diff --git a/plugin.xml b/plugin.xml index 398f3ae..b4fbe17 100644 --- a/plugin.xml +++ b/plugin.xml @@ -126,6 +126,9 @@ + + + diff --git a/src/ios/classes/CustomCamera.h b/src/ios/classes/CustomCamera.h index 23525ee..cf8e229 100755 --- a/src/ios/classes/CustomCamera.h +++ b/src/ios/classes/CustomCamera.h @@ -1,4 +1,61 @@ #import +#import +#import +enum CDVDestinationType { + DestinationTypeDataUrl = 0, + DestinationTypeFileUri, + DestinationTypeNativeUri +}; +typedef NSUInteger CDVDestinationType; + +enum CDVEncodingType { + EncodingTypeJPEG = 0, + EncodingTypePNG +}; +typedef NSUInteger CDVEncodingType; + +enum CDVMediaType { + MediaTypePicture = 0, + MediaTypeVideo, + MediaTypeAll +}; +typedef NSUInteger CDVMediaType; + +@interface CDVPictureOptions : NSObject + +@property (strong) NSNumber* quality; +@property (assign) CDVDestinationType destinationType; +@property (assign) UIImagePickerControllerSourceType sourceType; +@property (assign) CGSize targetSize; +@property (assign) CDVEncodingType encodingType; +@property (assign) CDVMediaType mediaType; +@property (assign) BOOL allowsEditing; +@property (assign) BOOL correctOrientation; +@property (assign) BOOL saveToPhotoAlbum; +@property (strong) NSDictionary* popoverOptions; +@property (assign) UIImagePickerControllerCameraDevice cameraDirection; + +@property (assign) BOOL popoverSupported; +@property (assign) BOOL usesGeolocation; +@property (assign) BOOL cropToSize; + ++ (instancetype) createFromTakePictureArguments:(CDVInvokedUrlCommand*)command; + +@end + +@interface CDVCameraPicker : UIImagePickerController + +@property (strong) CDVPictureOptions* pictureOptions; + +@property (copy) NSString* callbackId; +@property (copy) NSString* postUrl; +@property (strong) UIPopoverController* pickerPopoverController; +@property (assign) BOOL cropToSize; +@property (strong) UIView* webView; + ++ (instancetype) createFromPictureOptions:(CDVPictureOptions*)options; + +@end @interface CustomCamera : CDVPlugin { @@ -26,7 +83,11 @@ NSString *filename; } +@property (strong) NSData* data; +@property (strong) NSMutableDictionary *metadata; +@property (strong, nonatomic) CLLocationManager *locationManager; +@property (strong) CDVCameraPicker* pickerController; - (void)startCamera:(CDVInvokedUrlCommand*)command; - (void)takePicture:(CDVInvokedUrlCommand*)command; - +- (void)showCameraPicker:(NSString*)callbackId withOptions:(CDVPictureOptions *) pictureOptions; @end diff --git a/src/ios/classes/CustomCamera.m b/src/ios/classes/CustomCamera.m index 7ee671d..a2e9f1a 100755 --- a/src/ios/classes/CustomCamera.m +++ b/src/ios/classes/CustomCamera.m @@ -1,11 +1,487 @@ #import "CustomCamera.h" #import "AVCamViewController.h" #import "CameraParameter.h" +#import +#import +#import +#import "UIImage+CropScaleOrientation.h" +#import +#import + +#ifndef __CORDOVA_4_0_0 + #import +#endif + +#define CDV_PHOTO_PREFIX @"cdv_photo_" + +static NSSet* org_apache_cordova_validArrowDirections; +static NSString* toBase64(NSData* data) { + SEL s1 = NSSelectorFromString(@"cdv_base64EncodedString"); + SEL s2 = NSSelectorFromString(@"base64EncodedString"); + SEL s3 = NSSelectorFromString(@"base64EncodedStringWithOptions:"); + + if ([data respondsToSelector:s1]) { + NSString* (*func)(id, SEL) = (void *)[data methodForSelector:s1]; + return func(data, s1); + } else if ([data respondsToSelector:s2]) { + NSString* (*func)(id, SEL) = (void *)[data methodForSelector:s2]; + return func(data, s2); + } else if ([data respondsToSelector:s3]) { + NSString* (*func)(id, SEL, NSUInteger) = (void *)[data methodForSelector:s3]; + return func(data, s3, 0); + } else { + return nil; + } +} + +@implementation CDVPictureOptions + ++ (instancetype) createFromTakePictureArguments:(CDVInvokedUrlCommand*)command +{ + CDVPictureOptions* pictureOptions = [[CDVPictureOptions alloc] init]; + + pictureOptions.quality = [command argumentAtIndex:0 withDefault:@(50)]; + pictureOptions.destinationType = [[command argumentAtIndex:1 withDefault:@(DestinationTypeFileUri)] unsignedIntegerValue]; + pictureOptions.sourceType = [[command argumentAtIndex:2 withDefault:@(UIImagePickerControllerSourceTypeCamera)] unsignedIntegerValue]; + + NSNumber* targetWidth = [command argumentAtIndex:3 withDefault:nil]; + NSNumber* targetHeight = [command argumentAtIndex:4 withDefault:nil]; + pictureOptions.targetSize = CGSizeMake(0, 0); + if ((targetWidth != nil) && (targetHeight != nil)) { + pictureOptions.targetSize = CGSizeMake([targetWidth floatValue], [targetHeight floatValue]); + } + + pictureOptions.encodingType = [[command argumentAtIndex:5 withDefault:@(EncodingTypeJPEG)] unsignedIntegerValue]; + pictureOptions.mediaType = [[command argumentAtIndex:6 withDefault:@(MediaTypePicture)] unsignedIntegerValue]; + pictureOptions.allowsEditing = [[command argumentAtIndex:7 withDefault:@(NO)] boolValue]; + pictureOptions.correctOrientation = [[command argumentAtIndex:8 withDefault:@(NO)] boolValue]; + pictureOptions.saveToPhotoAlbum = [[command argumentAtIndex:9 withDefault:@(NO)] boolValue]; + pictureOptions.popoverOptions = [command argumentAtIndex:10 withDefault:nil]; + pictureOptions.cameraDirection = [[command argumentAtIndex:11 withDefault:@(UIImagePickerControllerCameraDeviceRear)] unsignedIntegerValue]; + + pictureOptions.popoverSupported = NO; + pictureOptions.usesGeolocation = NO; + + return pictureOptions; +} + +@end + + +@implementation CDVCameraPicker + +- (BOOL)prefersStatusBarHidden +{ + return YES; +} + +- (UIViewController*)childViewControllerForStatusBarHidden +{ + return nil; +} + +- (void)viewWillAppear:(BOOL)animated +{ + SEL sel = NSSelectorFromString(@"setNeedsStatusBarAppearanceUpdate"); + if ([self respondsToSelector:sel]) { + [self performSelector:sel withObject:nil afterDelay:0]; + } + + [super viewWillAppear:animated]; +} + ++ (instancetype) createFromPictureOptions:(CDVPictureOptions*)pictureOptions; +{ + CDVCameraPicker* cameraPicker = [[CDVCameraPicker alloc] init]; + cameraPicker.pictureOptions = pictureOptions; + cameraPicker.sourceType = pictureOptions.sourceType; + cameraPicker.allowsEditing = pictureOptions.allowsEditing; + + if (cameraPicker.sourceType == UIImagePickerControllerSourceTypeCamera) { + // We only allow taking pictures (no video) in this API. + cameraPicker.mediaTypes = @[(NSString*)kUTTypeImage]; + // We can only set the camera device if we're actually using the camera. + cameraPicker.cameraDevice = pictureOptions.cameraDirection; + } else if (pictureOptions.mediaType == MediaTypeAll) { + cameraPicker.mediaTypes = [UIImagePickerController availableMediaTypesForSourceType:cameraPicker.sourceType]; + } else { + NSArray* mediaArray = @[(NSString*)(pictureOptions.mediaType == MediaTypeVideo ? kUTTypeMovie : kUTTypeImage)]; + cameraPicker.mediaTypes = mediaArray; + } + + return cameraPicker; +} + +@end + +@interface CustomCamera () + @property (readwrite, assign) BOOL hasPendingOperation; +@end @implementation CustomCamera ++ (void)initialize +{ + org_apache_cordova_validArrowDirections = [[NSSet alloc] initWithObjects:[NSNumber numberWithInt:UIPopoverArrowDirectionUp], [NSNumber numberWithInt:UIPopoverArrowDirectionDown], [NSNumber numberWithInt:UIPopoverArrowDirectionLeft], [NSNumber numberWithInt:UIPopoverArrowDirectionRight], [NSNumber numberWithInt:UIPopoverArrowDirectionAny], nil]; +} + +@synthesize hasPendingOperation, pickerController; - (void)takePicture:(CDVInvokedUrlCommand *)command { - [self startCamera: command]; + self.hasPendingOperation = YES; + CDVPictureOptions* pictureOptions = [CDVPictureOptions createFromTakePictureArguments:command]; + if (pictureOptions.sourceType == 1) { + [self startCamera: command]; + } else { + [self showCameraPicker:command.callbackId withOptions:pictureOptions]; + } +} +- (BOOL)popoverSupported +{ + return (NSClassFromString(@"UIPopoverController") != nil) && + (UI_USER_INTERFACE_IDIOM() == UIUserInterfaceIdiomPad); +} + +- (NSInteger)integerValueForKey:(NSDictionary*)dict key:(NSString*)key defaultValue:(NSInteger)defaultValue +{ + NSInteger value = defaultValue; + + NSNumber* val = [dict valueForKey:key]; // value is an NSNumber + + if (val != nil) { + value = [val integerValue]; + } + return value; +} + +- (void)displayPopover:(NSDictionary*)options +{ + NSInteger x = 0; + NSInteger y = 32; + NSInteger width = 320; + NSInteger height = 480; + UIPopoverArrowDirection arrowDirection = UIPopoverArrowDirectionAny; + + if (options) { + x = [self integerValueForKey:options key:@"x" defaultValue:0]; + y = [self integerValueForKey:options key:@"y" defaultValue:32]; + width = [self integerValueForKey:options key:@"width" defaultValue:320]; + height = [self integerValueForKey:options key:@"height" defaultValue:480]; + arrowDirection = [self integerValueForKey:options key:@"arrowDir" defaultValue:UIPopoverArrowDirectionAny]; + if (![org_apache_cordova_validArrowDirections containsObject:[NSNumber numberWithUnsignedInteger:arrowDirection]]) { + arrowDirection = UIPopoverArrowDirectionAny; + } + } + + [[[self pickerController] pickerPopoverController] setDelegate:self]; + [[[self pickerController] pickerPopoverController] presentPopoverFromRect:CGRectMake(x, y, width, height) + inView:[self.webView superview] + permittedArrowDirections:arrowDirection + animated:YES]; +} + +- (void)showCameraPicker:(NSString*)callbackId withOptions:(CDVPictureOptions *) pictureOptions +{ + // Perform UI operations on the main thread + dispatch_async(dispatch_get_main_queue(), ^{ + CDVCameraPicker* cameraPicker = [CDVCameraPicker createFromPictureOptions:pictureOptions]; + self.pickerController = cameraPicker; + + cameraPicker.delegate = self; + cameraPicker.callbackId = callbackId; + // we need to capture this state for memory warnings that dealloc this object + cameraPicker.webView = self.webView; + + // If a popover is already open, close it; we only want one at a time. + if (([[self pickerController] pickerPopoverController] != nil) && [[[self pickerController] pickerPopoverController] isPopoverVisible]) { + [[[self pickerController] pickerPopoverController] dismissPopoverAnimated:YES]; + [[[self pickerController] pickerPopoverController] setDelegate:nil]; + [[self pickerController] setPickerPopoverController:nil]; + } + + if ([self popoverSupported] && (pictureOptions.sourceType != UIImagePickerControllerSourceTypeCamera)) { + if (cameraPicker.pickerPopoverController == nil) { + cameraPicker.pickerPopoverController = [[NSClassFromString(@"UIPopoverController") alloc] initWithContentViewController:cameraPicker]; + } + [self displayPopover:pictureOptions.popoverOptions]; + self.hasPendingOperation = NO; + } else { + cameraPicker.modalPresentationStyle = UIModalPresentationCurrentContext; + [self.viewController presentViewController:cameraPicker animated:YES completion:^{ + self.hasPendingOperation = NO; + }]; + } + }); +} +- (UIImage*)retrieveImage:(NSDictionary*)info options:(CDVPictureOptions*)options +{ + // get the image + UIImage* image = nil; + if (options.allowsEditing && [info objectForKey:UIImagePickerControllerEditedImage]) { + image = [info objectForKey:UIImagePickerControllerEditedImage]; + } else { + image = [info objectForKey:UIImagePickerControllerOriginalImage]; + } + + if (options.correctOrientation) { + image = [image imageCorrectedForCaptureOrientation]; + } + + UIImage* scaledImage = nil; + + if ((options.targetSize.width > 0) && (options.targetSize.height > 0)) { + // if cropToSize, resize image and crop to target size, otherwise resize to fit target without cropping + if (options.cropToSize) { + scaledImage = [image imageByScalingAndCroppingForSize:options.targetSize]; + } else { + scaledImage = [image imageByScalingNotCroppingForSize:options.targetSize]; + } + } + + return (scaledImage == nil ? image : scaledImage); +} + +- (NSURL*) urlTransformer:(NSURL*)url +{ + NSURL* urlToTransform = url; + + // for backwards compatibility - we check if this property is there + SEL sel = NSSelectorFromString(@"urlTransformer"); + if ([self.commandDelegate respondsToSelector:sel]) { + // grab the block from the commandDelegate + NSURL* (^urlTransformer)(NSURL*) = ((id(*)(id, SEL))objc_msgSend)(self.commandDelegate, sel); + // if block is not null, we call it + if (urlTransformer) { + urlToTransform = urlTransformer(url); + } + } + + return urlToTransform; +} + +- (NSData*)processImage:(UIImage*)image info:(NSDictionary*)info options:(CDVPictureOptions*)options +{ + NSData* data = nil; + + switch (options.encodingType) { + case EncodingTypePNG: + data = UIImagePNGRepresentation(image); + break; + case EncodingTypeJPEG: + { + if ((options.allowsEditing == NO) && (options.targetSize.width <= 0) && (options.targetSize.height <= 0) && (options.correctOrientation == NO) && (([options.quality integerValue] == 100) || (options.sourceType != UIImagePickerControllerSourceTypeCamera))){ + // use image unedited as requested , don't resize + data = UIImageJPEGRepresentation(image, 1.0); + } else { + data = UIImageJPEGRepresentation(image, [options.quality floatValue] / 100.0f); + } + + if (options.usesGeolocation) { + NSDictionary* controllerMetadata = [info objectForKey:@"UIImagePickerControllerMediaMetadata"]; + if (controllerMetadata) { + self.data = data; + self.metadata = [[NSMutableDictionary alloc] init]; + + NSMutableDictionary* EXIFDictionary = [[controllerMetadata objectForKey:(NSString*)kCGImagePropertyExifDictionary]mutableCopy]; + if (EXIFDictionary) { + [self.metadata setObject:EXIFDictionary forKey:(NSString*)kCGImagePropertyExifDictionary]; + } + + if (IsAtLeastiOSVersion(@"8.0")) { + [[self locationManager] performSelector:NSSelectorFromString(@"requestWhenInUseAuthorization") withObject:nil afterDelay:0]; + } + [[self locationManager] startUpdatingLocation]; + } + } + } + break; + default: + break; + }; + + return data; +} + +- (NSString*)tempFilePath:(NSString*)extension +{ + NSString* docsPath = [NSTemporaryDirectory()stringByStandardizingPath]; + NSFileManager* fileMgr = [[NSFileManager alloc] init]; // recommended by Apple (vs [NSFileManager defaultManager]) to be threadsafe + NSString* filePath; + + // unique file name + NSTimeInterval timeStamp = [[NSDate date] timeIntervalSince1970]; + NSNumber *timeStampObj = [NSNumber numberWithDouble: timeStamp]; + do { + filePath = [NSString stringWithFormat:@"%@/%@%ld.%@", docsPath, CDV_PHOTO_PREFIX, [timeStampObj longValue], extension]; + } while ([fileMgr fileExistsAtPath:filePath]); + + return filePath; +} + +- (void)resultForImage:(CDVPictureOptions*)options info:(NSDictionary*)info completion:(void (^)(CDVPluginResult* res))completion +{ + CDVPluginResult* result = nil; + BOOL saveToPhotoAlbum = options.saveToPhotoAlbum; + UIImage* image = nil; + + switch (options.destinationType) { + case DestinationTypeNativeUri: + { + NSURL* url = [info objectForKey:UIImagePickerControllerReferenceURL]; + saveToPhotoAlbum = NO; + // If, for example, we use sourceType = Camera, URL might be nil because image is stored in memory. + // In this case we must save image to device before obtaining an URI. + if (url == nil) { + image = [self retrieveImage:info options:options]; + ALAssetsLibrary* library = [ALAssetsLibrary new]; + [library writeImageToSavedPhotosAlbum:image.CGImage orientation:(ALAssetOrientation)(image.imageOrientation) completionBlock:^(NSURL *assetURL, NSError *error) { + CDVPluginResult* resultToReturn = nil; + if (error) { + resultToReturn = [CDVPluginResult resultWithStatus:CDVCommandStatus_IO_EXCEPTION messageAsString:[error localizedDescription]]; + } else { + NSString* nativeUri = [[self urlTransformer:assetURL] absoluteString]; + resultToReturn = [CDVPluginResult resultWithStatus:CDVCommandStatus_OK messageAsString:nativeUri]; + } + completion(resultToReturn); + }]; + return; + } else { + NSString* nativeUri = [[self urlTransformer:url] absoluteString]; + result = [CDVPluginResult resultWithStatus:CDVCommandStatus_OK messageAsString:nativeUri]; + } + } + break; + case DestinationTypeFileUri: + { + image = [self retrieveImage:info options:options]; + NSData* data = [self processImage:image info:info options:options]; + if (data) { + + NSString* extension = options.encodingType == EncodingTypePNG? @"png" : @"jpg"; + NSString* filePath = [self tempFilePath:extension]; + NSError* err = nil; + + // save file + if (![data writeToFile:filePath options:NSAtomicWrite error:&err]) { + result = [CDVPluginResult resultWithStatus:CDVCommandStatus_IO_EXCEPTION messageAsString:[err localizedDescription]]; + } else { + result = [CDVPluginResult resultWithStatus:CDVCommandStatus_OK messageAsString:[[self urlTransformer:[NSURL fileURLWithPath:filePath]] absoluteString]]; + } + } + } + break; + case DestinationTypeDataUrl: + { + image = [self retrieveImage:info options:options]; + NSData* data = [self processImage:image info:info options:options]; + if (data) { + result = [CDVPluginResult resultWithStatus:CDVCommandStatus_OK messageAsString:toBase64(data)]; + } + } + break; + default: + break; + }; + + if (saveToPhotoAlbum && image) { + ALAssetsLibrary* library = [ALAssetsLibrary new]; + [library writeImageToSavedPhotosAlbum:image.CGImage orientation:(ALAssetOrientation)(image.imageOrientation) completionBlock:nil]; + } + + completion(result); +} + +- (NSString *) createTmpVideo:(NSString *) moviePath { + NSString* moviePathExtension = [moviePath pathExtension]; + NSString* copyMoviePath = [self tempFilePath:moviePathExtension]; + NSFileManager* fileMgr = [[NSFileManager alloc] init]; + NSError *error; + [fileMgr copyItemAtPath:moviePath toPath:copyMoviePath error:&error]; + return [[NSURL fileURLWithPath:copyMoviePath] absoluteString]; +} + +- (CDVPluginResult*)resultForVideo:(NSDictionary*)info +{ + NSString* moviePath = [[info objectForKey:UIImagePickerControllerMediaURL] absoluteString]; + // On iOS 13 the movie path becomes inaccessible, create and return a copy + if (IsAtLeastiOSVersion(@"13.0")) { + moviePath = [self createTmpVideo:[[info objectForKey:UIImagePickerControllerMediaURL] path]]; + } + return [CDVPluginResult resultWithStatus:CDVCommandStatus_OK messageAsString:moviePath]; +} + +- (BOOL)usesGeolocation +{ + id useGeo = [self.commandDelegate.settings objectForKey:[@"CameraUsesGeolocation" lowercaseString]]; + return [(NSNumber*)useGeo boolValue]; +} + +- (void)imagePickerController:(UIImagePickerController*)picker didFinishPickingMediaWithInfo:(NSDictionary*)info +{ + __weak CDVCameraPicker* cameraPicker = (CDVCameraPicker*)picker; + __weak CustomCamera* weakSelf = self; + + dispatch_block_t invoke = ^(void) { + __block CDVPluginResult* result = nil; + + NSString* mediaType = [info objectForKey:UIImagePickerControllerMediaType]; + if ([mediaType isEqualToString:(NSString*)kUTTypeImage]) { + [weakSelf resultForImage:cameraPicker.pictureOptions info:info completion:^(CDVPluginResult* res) { + if (![self usesGeolocation] || picker.sourceType != UIImagePickerControllerSourceTypeCamera) { + [weakSelf.commandDelegate sendPluginResult:res callbackId:cameraPicker.callbackId]; + weakSelf.hasPendingOperation = NO; + weakSelf.pickerController = nil; + } + }]; + } + else { + result = [weakSelf resultForVideo:info]; + [weakSelf.commandDelegate sendPluginResult:result callbackId:cameraPicker.callbackId]; + weakSelf.hasPendingOperation = NO; + weakSelf.pickerController = nil; + } + }; + + if (cameraPicker.pictureOptions.popoverSupported && (cameraPicker.pickerPopoverController != nil)) { + [cameraPicker.pickerPopoverController dismissPopoverAnimated:YES]; + cameraPicker.pickerPopoverController.delegate = nil; + cameraPicker.pickerPopoverController = nil; + invoke(); + } else { + [[cameraPicker presentingViewController] dismissViewControllerAnimated:YES completion:invoke]; + } +} + +// older api calls newer didFinishPickingMediaWithInfo +- (void)imagePickerController:(UIImagePickerController*)picker didFinishPickingImage:(UIImage*)image editingInfo:(NSDictionary*)editingInfo +{ + NSDictionary* imageInfo = [NSDictionary dictionaryWithObject:image forKey:UIImagePickerControllerOriginalImage]; + + [self imagePickerController:picker didFinishPickingMediaWithInfo:imageInfo]; +} + +- (void)imagePickerControllerDidCancel:(UIImagePickerController*)picker +{ + __weak CDVCameraPicker* cameraPicker = (CDVCameraPicker*)picker; + __weak CustomCamera* weakSelf = self; + + dispatch_block_t invoke = ^ (void) { + CDVPluginResult* result; + if (picker.sourceType == UIImagePickerControllerSourceTypeCamera && [AVCaptureDevice authorizationStatusForMediaType:AVMediaTypeVideo] != ALAuthorizationStatusAuthorized) { + result = [CDVPluginResult resultWithStatus:CDVCommandStatus_ERROR messageAsString:@"has no access to camera"]; + } else if (picker.sourceType != UIImagePickerControllerSourceTypeCamera && ! IsAtLeastiOSVersion(@"11.0") && [ALAssetsLibrary authorizationStatus] != ALAuthorizationStatusAuthorized) { + result = [CDVPluginResult resultWithStatus:CDVCommandStatus_ERROR messageAsString:@"has no access to assets"]; + } else { + result = [CDVPluginResult resultWithStatus:CDVCommandStatus_ERROR messageAsString:@"No Image Selected"]; + } + + + [weakSelf.commandDelegate sendPluginResult:result callbackId:cameraPicker.callbackId]; + + weakSelf.hasPendingOperation = NO; + weakSelf.pickerController = nil; + }; + + [[cameraPicker presentingViewController] dismissViewControllerAnimated:YES completion:invoke]; } - (void)startCamera:(CDVInvokedUrlCommand *)command { @@ -73,37 +549,6 @@ } } -// This method is called when an image has been chosen from the library or taken from the camera. -- (void)imagePickerController:(UIImagePickerController *)picker didFinishPickingMediaWithInfo:(NSDictionary *)info { - //You can retrieve the actual UIImage - UIImage *image = [info valueForKey:UIImagePickerControllerOriginalImage]; - //Or you can get the image url from AssetsLibrary - // NSURL *path = [info valueForKey:UIImagePickerControllerReferenceURL]; - - [picker dismissViewControllerAnimated:YES completion: ^{ - @autoreleasepool { - if (nDestType == 0) { - NSData *imageData = UIImageJPEGRepresentation(image, quality / 100); - - NSString *strEncodeData = [imageData base64EncodedStringWithOptions:0]; - CDVPluginResult *result = [CDVPluginResult resultWithStatus:CDVCommandStatus_OK - messageAsString:strEncodeData]; - [self.commandDelegate sendPluginResult:result callbackId:lastCommand.callbackId]; - } - else { - NSString *documentsDirectory = [NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES) objectAtIndex:0]; - NSString *imagePath = [documentsDirectory stringByAppendingPathComponent:filename]; - NSData *imageData = UIImageJPEGRepresentation(image, quality / 100); - //[self deleteFileWithName:imagePath]; - [imageData writeToFile:imagePath atomically:YES]; - CDVPluginResult *result = [CDVPluginResult resultWithStatus:CDVCommandStatus_OK - messageAsString:[[NSURL fileURLWithPath:imagePath] absoluteString]]; - [self.commandDelegate sendPluginResult:result callbackId:lastCommand.callbackId]; - } - } - }]; -} - - (void)deleteFileWithName:(NSString *)fileName { NSFileManager *manager = [NSFileManager defaultManager]; // Need to check if the to be deleted file exists.