|
|
@@ -0,0 +1,1589 @@
|
|
|
+#import <Foundation/Foundation.h>
|
|
|
+#import <Photos/Photos.h>
|
|
|
+#import <MobileCoreServices/UTCoreTypes.h>
|
|
|
+#import <MobileCoreServices/MobileCoreServices.h>
|
|
|
+#import <ImageIO/ImageIO.h>
|
|
|
+#if __IPHONE_OS_VERSION_MIN_REQUIRED < 80000
|
|
|
+#import <AssetsLibrary/AssetsLibrary.h>
|
|
|
+#endif
|
|
|
+#if __IPHONE_OS_VERSION_MAX_ALLOWED >= 140000
|
|
|
+#import <PhotosUI/PhotosUI.h>
|
|
|
+#endif
|
|
|
+
|
|
|
+#ifdef UNITY_4_0 || UNITY_5_0
|
|
|
+#import "iPhone_View.h"
|
|
|
+#else
|
|
|
+extern UIViewController* UnityGetGLViewController();
|
|
|
+#endif
|
|
|
+
|
|
|
+#define CHECK_IOS_VERSION( version ) ([[[UIDevice currentDevice] systemVersion] compare:version options:NSNumericSearch] != NSOrderedAscending)
|
|
|
+
|
|
|
+@interface UNativeGallery:NSObject
|
|
|
++ (int)checkPermission:(BOOL)readPermission permissionFreeMode:(BOOL)permissionFreeMode;
|
|
|
++ (int)requestPermission:(BOOL)readPermission permissionFreeMode:(BOOL)permissionFreeMode asyncMode:(BOOL)asyncMode;
|
|
|
++ (void)showLimitedLibraryPicker;
|
|
|
++ (int)canOpenSettings;
|
|
|
++ (void)openSettings;
|
|
|
++ (int)canPickMultipleMedia;
|
|
|
++ (void)saveMedia:(NSString *)path albumName:(NSString *)album isImg:(BOOL)isImg permissionFreeMode:(BOOL)permissionFreeMode;
|
|
|
++ (void)pickMedia:(int)mediaType savePath:(NSString *)mediaSavePath permissionFreeMode:(BOOL)permissionFreeMode selectionLimit:(int)selectionLimit;
|
|
|
++ (int)isMediaPickerBusy;
|
|
|
++ (int)getMediaTypeFromExtension:(NSString *)extension;
|
|
|
++ (char *)getImageProperties:(NSString *)path;
|
|
|
++ (char *)getVideoProperties:(NSString *)path;
|
|
|
++ (char *)getVideoThumbnail:(NSString *)path savePath:(NSString *)savePath maximumSize:(int)maximumSize captureTime:(double)captureTime;
|
|
|
++ (char *)loadImageAtPath:(NSString *)path tempFilePath:(NSString *)tempFilePath maximumSize:(int)maximumSize;
|
|
|
+@end
|
|
|
+
|
|
|
+@implementation UNativeGallery
|
|
|
+
|
|
|
+static NSString *pickedMediaSavePath;
|
|
|
+static UIPopoverController *popup;
|
|
|
+static UIImagePickerController *imagePicker;
|
|
|
+#if __IPHONE_OS_VERSION_MAX_ALLOWED >= 140000
|
|
|
+static PHPickerViewController *imagePickerNew;
|
|
|
+#endif
|
|
|
+static int imagePickerState = 0; // 0 -> none, 1 -> showing (always in this state on iPad), 2 -> finished
|
|
|
+static BOOL simpleMediaPickMode;
|
|
|
+static BOOL pickingMultipleFiles = NO;
|
|
|
+
|
|
|
+#pragma clang diagnostic push
|
|
|
+#pragma clang diagnostic ignored "-Wdeprecated-declarations"
|
|
|
++ (int)checkPermission:(BOOL)readPermission permissionFreeMode:(BOOL)permissionFreeMode
|
|
|
+{
|
|
|
+#if __IPHONE_OS_VERSION_MIN_REQUIRED < 80000
|
|
|
+ if( CHECK_IOS_VERSION( @"8.0" ) )
|
|
|
+ {
|
|
|
+#endif
|
|
|
+ // version >= iOS 8: check permission using Photos framework
|
|
|
+
|
|
|
+ // On iOS 11 and later, permission isn't mandatory to fetch media from Photos
|
|
|
+ if( readPermission && permissionFreeMode && CHECK_IOS_VERSION( @"11.0" ) )
|
|
|
+ return 1;
|
|
|
+
|
|
|
+#if __IPHONE_OS_VERSION_MAX_ALLOWED >= 140000
|
|
|
+ // Photos permissions has changed on iOS 14
|
|
|
+ if( CHECK_IOS_VERSION( @"14.0" ) )
|
|
|
+ {
|
|
|
+ // Request ReadWrite permission in 2 cases:
|
|
|
+ // 1) When attempting to pick media from Photos with PHPhotoLibrary (readPermission=true and permissionFreeMode=false)
|
|
|
+ // 2) When attempting to write media to a specific album in Photos using PHPhotoLibrary (readPermission=false and permissionFreeMode=false)
|
|
|
+ PHAuthorizationStatus status = [PHPhotoLibrary authorizationStatusForAccessLevel:( ( readPermission || !permissionFreeMode ) ? PHAccessLevelReadWrite : PHAccessLevelAddOnly )];
|
|
|
+ if( status == PHAuthorizationStatusAuthorized )
|
|
|
+ return 1;
|
|
|
+ else if( status == PHAuthorizationStatusRestricted )
|
|
|
+ return 3;
|
|
|
+ else if( status == PHAuthorizationStatusNotDetermined )
|
|
|
+ return 2;
|
|
|
+ else
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+ else
|
|
|
+#endif
|
|
|
+ {
|
|
|
+ PHAuthorizationStatus status = [PHPhotoLibrary authorizationStatus];
|
|
|
+ if( status == PHAuthorizationStatusAuthorized )
|
|
|
+ return 1;
|
|
|
+ else if( status == PHAuthorizationStatusNotDetermined )
|
|
|
+ return 2;
|
|
|
+ else
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+#if __IPHONE_OS_VERSION_MIN_REQUIRED < 80000
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ // version < iOS 8: check permission using AssetsLibrary framework (Photos framework not available)
|
|
|
+ ALAuthorizationStatus status = [ALAssetsLibrary authorizationStatus];
|
|
|
+ if( status == ALAuthorizationStatusAuthorized )
|
|
|
+ return 1;
|
|
|
+ else if( status == ALAuthorizationStatusNotDetermined )
|
|
|
+ return 2;
|
|
|
+ else
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+#endif
|
|
|
+}
|
|
|
+#pragma clang diagnostic pop
|
|
|
+
|
|
|
++ (int)requestPermission:(BOOL)readPermission permissionFreeMode:(BOOL)permissionFreeMode asyncMode:(BOOL)asyncMode
|
|
|
+{
|
|
|
+ int result;
|
|
|
+#if __IPHONE_OS_VERSION_MIN_REQUIRED < 80000
|
|
|
+ if( CHECK_IOS_VERSION( @"8.0" ) )
|
|
|
+ {
|
|
|
+#endif
|
|
|
+ // version >= iOS 8: request permission using Photos framework
|
|
|
+
|
|
|
+ // On iOS 11 and later, permission isn't mandatory to fetch media from Photos
|
|
|
+ if( readPermission && permissionFreeMode && CHECK_IOS_VERSION( @"11.0" ) )
|
|
|
+ result = 1;
|
|
|
+#if __IPHONE_OS_VERSION_MAX_ALLOWED >= 140000
|
|
|
+ else if( CHECK_IOS_VERSION( @"14.0" ) )
|
|
|
+ {
|
|
|
+ // Photos permissions has changed on iOS 14. There are 2 permission dialogs now:
|
|
|
+ // - AddOnly permission dialog: has 2 options: "Allow" and "Don't Allow". This dialog grants permission for save operations only. Unfortunately,
|
|
|
+ // saving media to a custom album isn't possible with this dialog, media can only be saved to the default Photos album
|
|
|
+ // - ReadWrite permission dialog: has 3 options: "Allow Access to All Photos" (i.e. full permission), "Select Photos" (i.e. limited access) and
|
|
|
+ // "Don't Allow". To be able to save media to a custom album, user must grant Full Photos permission. Thus, even when readPermission is false,
|
|
|
+ // this dialog will be used if PermissionFreeMode is set to false. So, PermissionFreeMode determines whether or not saving to a custom album is
|
|
|
+ // be supported
|
|
|
+ result = [self requestPermissionNewest:( readPermission || !permissionFreeMode ) asyncMode:asyncMode];
|
|
|
+ }
|
|
|
+#endif
|
|
|
+ else
|
|
|
+ result = [self requestPermissionNew:asyncMode];
|
|
|
+#if __IPHONE_OS_VERSION_MIN_REQUIRED < 80000
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ // version < iOS 8: request permission using AssetsLibrary framework (Photos framework not available)
|
|
|
+ result = [self requestPermissionOld:asyncMode];
|
|
|
+ }
|
|
|
+
|
|
|
+ if( asyncMode && result >= 0 ) // Result returned immediately, forward it
|
|
|
+ UnitySendMessage( "NGPermissionCallbackiOS", "OnPermissionRequested", [self getCString:[NSString stringWithFormat:@"%d", result]] );
|
|
|
+
|
|
|
+ return result;
|
|
|
+#endif
|
|
|
+}
|
|
|
+
|
|
|
+#if __IPHONE_OS_VERSION_MIN_REQUIRED < 80000
|
|
|
+// Credit: https://stackoverflow.com/a/26933380/2373034
|
|
|
+#pragma clang diagnostic push
|
|
|
+#pragma clang diagnostic ignored "-Wdeprecated-declarations"
|
|
|
++ (int)requestPermissionOld:(BOOL)asyncMode
|
|
|
+{
|
|
|
+ ALAuthorizationStatus status = [ALAssetsLibrary authorizationStatus];
|
|
|
+
|
|
|
+ if( status == ALAuthorizationStatusAuthorized )
|
|
|
+ return 1;
|
|
|
+ else if( status == ALAuthorizationStatusNotDetermined )
|
|
|
+ {
|
|
|
+ if( asyncMode )
|
|
|
+ {
|
|
|
+ [[[ALAssetsLibrary alloc] init] enumerateGroupsWithTypes:ALAssetsGroupAll usingBlock:^( ALAssetsGroup *group, BOOL *stop )
|
|
|
+ {
|
|
|
+ *stop = YES;
|
|
|
+ UnitySendMessage( "NGPermissionCallbackiOS", "OnPermissionRequested", "1" );
|
|
|
+ }
|
|
|
+ failureBlock:^( NSError *error )
|
|
|
+ {
|
|
|
+ UnitySendMessage( "NGPermissionCallbackiOS", "OnPermissionRequested", "0" );
|
|
|
+ }];
|
|
|
+
|
|
|
+ return -1;
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ __block BOOL authorized = NO;
|
|
|
+ dispatch_semaphore_t sema = dispatch_semaphore_create( 0 );
|
|
|
+ [[[ALAssetsLibrary alloc] init] enumerateGroupsWithTypes:ALAssetsGroupAll usingBlock:^( ALAssetsGroup *group, BOOL *stop )
|
|
|
+ {
|
|
|
+ *stop = YES;
|
|
|
+ authorized = YES;
|
|
|
+ dispatch_semaphore_signal( sema );
|
|
|
+ }
|
|
|
+ failureBlock:^( NSError *error )
|
|
|
+ {
|
|
|
+ dispatch_semaphore_signal( sema );
|
|
|
+ }];
|
|
|
+ dispatch_semaphore_wait( sema, DISPATCH_TIME_FOREVER );
|
|
|
+
|
|
|
+ return authorized ? 1 : 0;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ return 0;
|
|
|
+}
|
|
|
+#pragma clang diagnostic pop
|
|
|
+#endif
|
|
|
+
|
|
|
+// Credit: https://stackoverflow.com/a/32989022/2373034
|
|
|
++ (int)requestPermissionNew:(BOOL)asyncMode
|
|
|
+{
|
|
|
+ PHAuthorizationStatus status = [PHPhotoLibrary authorizationStatus];
|
|
|
+
|
|
|
+ if( status == PHAuthorizationStatusAuthorized )
|
|
|
+ return 1;
|
|
|
+ else if( status == PHAuthorizationStatusNotDetermined )
|
|
|
+ {
|
|
|
+ if( asyncMode )
|
|
|
+ {
|
|
|
+ [PHPhotoLibrary requestAuthorization:^( PHAuthorizationStatus status )
|
|
|
+ {
|
|
|
+ UnitySendMessage( "NGPermissionCallbackiOS", "OnPermissionRequested", ( status == PHAuthorizationStatusAuthorized ) ? "1" : "0" );
|
|
|
+ }];
|
|
|
+
|
|
|
+ return -1;
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ __block BOOL authorized = NO;
|
|
|
+
|
|
|
+ dispatch_semaphore_t sema = dispatch_semaphore_create( 0 );
|
|
|
+ [PHPhotoLibrary requestAuthorization:^( PHAuthorizationStatus status )
|
|
|
+ {
|
|
|
+ authorized = ( status == PHAuthorizationStatusAuthorized );
|
|
|
+ dispatch_semaphore_signal( sema );
|
|
|
+ }];
|
|
|
+ dispatch_semaphore_wait( sema, DISPATCH_TIME_FOREVER );
|
|
|
+
|
|
|
+ return authorized ? 1 : 0;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ return 0;
|
|
|
+}
|
|
|
+
|
|
|
+#if __IPHONE_OS_VERSION_MAX_ALLOWED >= 140000
|
|
|
++ (int)requestPermissionNewest:(BOOL)readPermission asyncMode:(BOOL)asyncMode
|
|
|
+{
|
|
|
+ PHAuthorizationStatus status = [PHPhotoLibrary authorizationStatusForAccessLevel:( readPermission ? PHAccessLevelReadWrite : PHAccessLevelAddOnly )];
|
|
|
+
|
|
|
+ if( status == PHAuthorizationStatusAuthorized )
|
|
|
+ return 1;
|
|
|
+ else if( status == PHAuthorizationStatusRestricted )
|
|
|
+ return 3;
|
|
|
+ else if( status == PHAuthorizationStatusNotDetermined )
|
|
|
+ {
|
|
|
+ if( asyncMode )
|
|
|
+ {
|
|
|
+ [PHPhotoLibrary requestAuthorizationForAccessLevel:( readPermission ? PHAccessLevelReadWrite : PHAccessLevelAddOnly ) handler:^( PHAuthorizationStatus status )
|
|
|
+ {
|
|
|
+ if( status == PHAuthorizationStatusAuthorized )
|
|
|
+ UnitySendMessage( "NGPermissionCallbackiOS", "OnPermissionRequested", "1" );
|
|
|
+ else if( status == PHAuthorizationStatusRestricted )
|
|
|
+ UnitySendMessage( "NGPermissionCallbackiOS", "OnPermissionRequested", "3" );
|
|
|
+ else
|
|
|
+ UnitySendMessage( "NGPermissionCallbackiOS", "OnPermissionRequested", "0" );
|
|
|
+ }];
|
|
|
+
|
|
|
+ return -1;
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ __block int authorized = 0;
|
|
|
+
|
|
|
+ dispatch_semaphore_t sema = dispatch_semaphore_create( 0 );
|
|
|
+ [PHPhotoLibrary requestAuthorizationForAccessLevel:( readPermission ? PHAccessLevelReadWrite : PHAccessLevelAddOnly ) handler:^( PHAuthorizationStatus status )
|
|
|
+ {
|
|
|
+ if( status == PHAuthorizationStatusAuthorized )
|
|
|
+ authorized = 1;
|
|
|
+ else if( status == PHAuthorizationStatusRestricted )
|
|
|
+ authorized = 3;
|
|
|
+
|
|
|
+ dispatch_semaphore_signal( sema );
|
|
|
+ }];
|
|
|
+ dispatch_semaphore_wait( sema, DISPATCH_TIME_FOREVER );
|
|
|
+
|
|
|
+ return authorized;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ return 0;
|
|
|
+}
|
|
|
+#endif
|
|
|
+
|
|
|
+// When Photos permission is set to restricted, allows user to change the permission or change the list of restricted images
|
|
|
+// It doesn't support a deterministic callback; for example there is a photoLibraryDidChange event but it won't be invoked if
|
|
|
+// user doesn't change the list of restricted images
|
|
|
++ (void)showLimitedLibraryPicker
|
|
|
+{
|
|
|
+#if __IPHONE_OS_VERSION_MAX_ALLOWED >= 140000
|
|
|
+ PHAuthorizationStatus status = [PHPhotoLibrary authorizationStatusForAccessLevel:PHAccessLevelReadWrite];
|
|
|
+ if( status == PHAuthorizationStatusNotDetermined )
|
|
|
+ [self requestPermissionNewest:YES asyncMode:YES];
|
|
|
+ else if( status == PHAuthorizationStatusRestricted )
|
|
|
+ [[PHPhotoLibrary sharedPhotoLibrary] presentLimitedLibraryPickerFromViewController:UnityGetGLViewController()];
|
|
|
+#endif
|
|
|
+}
|
|
|
+
|
|
|
+// Credit: https://stackoverflow.com/a/25453667/2373034
|
|
|
++ (int)canOpenSettings
|
|
|
+{
|
|
|
+ return ( &UIApplicationOpenSettingsURLString != NULL ) ? 1 : 0;
|
|
|
+}
|
|
|
+
|
|
|
+// Credit: https://stackoverflow.com/a/25453667/2373034
|
|
|
+#pragma clang diagnostic push
|
|
|
+#pragma clang diagnostic ignored "-Wdeprecated-declarations"
|
|
|
++ (void)openSettings
|
|
|
+{
|
|
|
+ if( &UIApplicationOpenSettingsURLString != NULL )
|
|
|
+ {
|
|
|
+#if __IPHONE_OS_VERSION_MAX_ALLOWED >= 100000
|
|
|
+ if( CHECK_IOS_VERSION( @"10.0" ) )
|
|
|
+ [[UIApplication sharedApplication] openURL:[NSURL URLWithString:UIApplicationOpenSettingsURLString] options:@{} completionHandler:nil];
|
|
|
+ else
|
|
|
+#endif
|
|
|
+ [[UIApplication sharedApplication] openURL:[NSURL URLWithString:UIApplicationOpenSettingsURLString]];
|
|
|
+ }
|
|
|
+}
|
|
|
+#pragma clang diagnostic pop
|
|
|
+
|
|
|
++ (int)canPickMultipleMedia
|
|
|
+{
|
|
|
+#if __IPHONE_OS_VERSION_MAX_ALLOWED >= 140000
|
|
|
+ if( CHECK_IOS_VERSION( @"14.0" ) )
|
|
|
+ return 1;
|
|
|
+ else
|
|
|
+#endif
|
|
|
+ return 0;
|
|
|
+}
|
|
|
+
|
|
|
++ (void)saveMedia:(NSString *)path albumName:(NSString *)album isImg:(BOOL)isImg permissionFreeMode:(BOOL)permissionFreeMode
|
|
|
+{
|
|
|
+#if __IPHONE_OS_VERSION_MIN_REQUIRED < 80000
|
|
|
+ if( CHECK_IOS_VERSION( @"8.0" ) )
|
|
|
+ {
|
|
|
+#endif
|
|
|
+ // version >= iOS 8: save to specified album using Photos framework
|
|
|
+ // On iOS 14+, permission workflow has changed significantly with the addition of PHAuthorizationStatusRestricted permission. On those versions,
|
|
|
+ // user must grant Full Photos permission to be able to save to a custom album. Hence, there are 2 workflows:
|
|
|
+ // - If PermissionFreeMode is enabled, save the media directly to the default album (i.e. ignore 'album' parameter). This will present a simple
|
|
|
+ // permission dialog stating "The app requires access to Photos to save media to it." and the "Selected Photos" permission won't be listed in the options
|
|
|
+ // - Otherwise, the more complex "The app requires access to Photos to interact with it." permission dialog will be shown and if the user grants
|
|
|
+ // Full Photos permission, only then the image will be saved to the specified album. If user selects "Selected Photos" permission, default album will be
|
|
|
+ // used as fallback
|
|
|
+ [self saveMediaNew:path albumName:album isImage:isImg saveToDefaultAlbum:( permissionFreeMode && CHECK_IOS_VERSION( @"14.0" ) )];
|
|
|
+#if __IPHONE_OS_VERSION_MIN_REQUIRED < 80000
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ // version < iOS 8: save using AssetsLibrary framework (Photos framework not available)
|
|
|
+ [self saveMediaOld:path albumName:album isImage:isImg];
|
|
|
+ }
|
|
|
+#endif
|
|
|
+}
|
|
|
+
|
|
|
+#if __IPHONE_OS_VERSION_MIN_REQUIRED < 80000
|
|
|
+// Credit: https://stackoverflow.com/a/22056664/2373034
|
|
|
+#pragma clang diagnostic push
|
|
|
+#pragma clang diagnostic ignored "-Wdeprecated-declarations"
|
|
|
++ (void)saveMediaOld:(NSString *)path albumName:(NSString *)album isImage:(BOOL)isImage
|
|
|
+{
|
|
|
+ ALAssetsLibrary *library = [[ALAssetsLibrary alloc] init];
|
|
|
+
|
|
|
+ if( !isImage && ![library videoAtPathIsCompatibleWithSavedPhotosAlbum:[NSURL fileURLWithPath:path]])
|
|
|
+ {
|
|
|
+ NSLog( @"Error saving video: Video format is not compatible with Photos" );
|
|
|
+ [[NSFileManager defaultManager] removeItemAtPath:path error:nil];
|
|
|
+ UnitySendMessage( "NGMediaSaveCallbackiOS", "OnMediaSaveFailed", "" );
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ void (^saveBlock)(ALAssetsGroup *assetCollection) = ^void( ALAssetsGroup *assetCollection )
|
|
|
+ {
|
|
|
+ void (^saveResultBlock)(NSURL *assetURL, NSError *error) = ^void( NSURL *assetURL, NSError *error )
|
|
|
+ {
|
|
|
+ [[NSFileManager defaultManager] removeItemAtPath:path error:nil];
|
|
|
+
|
|
|
+ if( error.code == 0 )
|
|
|
+ {
|
|
|
+ [library assetForURL:assetURL resultBlock:^( ALAsset *asset )
|
|
|
+ {
|
|
|
+ [assetCollection addAsset:asset];
|
|
|
+ UnitySendMessage( "NGMediaSaveCallbackiOS", "OnMediaSaveCompleted", "" );
|
|
|
+ }
|
|
|
+ failureBlock:^( NSError* error )
|
|
|
+ {
|
|
|
+ NSLog( @"Error moving asset to album: %@", error );
|
|
|
+ UnitySendMessage( "NGMediaSaveCallbackiOS", "OnMediaSaveFailed", "" );
|
|
|
+ }];
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ NSLog( @"Error creating asset: %@", error );
|
|
|
+ UnitySendMessage( "NGMediaSaveCallbackiOS", "OnMediaSaveFailed", "" );
|
|
|
+ }
|
|
|
+ };
|
|
|
+
|
|
|
+ if( !isImage )
|
|
|
+ [library writeImageDataToSavedPhotosAlbum:[NSData dataWithContentsOfFile:path] metadata:nil completionBlock:saveResultBlock];
|
|
|
+ else
|
|
|
+ [library writeVideoAtPathToSavedPhotosAlbum:[NSURL fileURLWithPath:path] completionBlock:saveResultBlock];
|
|
|
+ };
|
|
|
+
|
|
|
+ __block BOOL albumFound = NO;
|
|
|
+ [library enumerateGroupsWithTypes:ALAssetsGroupAlbum usingBlock:^( ALAssetsGroup *group, BOOL *stop )
|
|
|
+ {
|
|
|
+ if( [[group valueForProperty:ALAssetsGroupPropertyName] isEqualToString:album] )
|
|
|
+ {
|
|
|
+ *stop = YES;
|
|
|
+ albumFound = YES;
|
|
|
+ saveBlock( group );
|
|
|
+ }
|
|
|
+ else if( group == nil && albumFound==NO )
|
|
|
+ {
|
|
|
+ // Album doesn't exist
|
|
|
+ [library addAssetsGroupAlbumWithName:album resultBlock:^( ALAssetsGroup *group )
|
|
|
+ {
|
|
|
+ saveBlock( group );
|
|
|
+ }
|
|
|
+ failureBlock:^( NSError *error )
|
|
|
+ {
|
|
|
+ NSLog( @"Error creating album: %@", error );
|
|
|
+ [[NSFileManager defaultManager] removeItemAtPath:path error:nil];
|
|
|
+ UnitySendMessage( "NGMediaSaveCallbackiOS", "OnMediaSaveFailed", "" );
|
|
|
+ }];
|
|
|
+ }
|
|
|
+ }
|
|
|
+ failureBlock:^( NSError* error )
|
|
|
+ {
|
|
|
+ NSLog( @"Error listing albums: %@", error );
|
|
|
+ [[NSFileManager defaultManager] removeItemAtPath:path error:nil];
|
|
|
+ UnitySendMessage( "NGMediaSaveCallbackiOS", "OnMediaSaveFailed", "" );
|
|
|
+ }];
|
|
|
+}
|
|
|
+#pragma clang diagnostic pop
|
|
|
+#endif
|
|
|
+
|
|
|
+// Credit: https://stackoverflow.com/a/39909129/2373034
|
|
|
++ (void)saveMediaNew:(NSString *)path albumName:(NSString *)album isImage:(BOOL)isImage saveToDefaultAlbum:(BOOL)saveToDefaultAlbum
|
|
|
+{
|
|
|
+ void (^saveToPhotosAlbum)() = ^void()
|
|
|
+ {
|
|
|
+ if( isImage )
|
|
|
+ {
|
|
|
+ // Try preserving image metadata (essential for animated gif images)
|
|
|
+ [[PHPhotoLibrary sharedPhotoLibrary] performChanges:
|
|
|
+ ^{
|
|
|
+ [PHAssetChangeRequest creationRequestForAssetFromImageAtFileURL:[NSURL fileURLWithPath:path]];
|
|
|
+ }
|
|
|
+ completionHandler:^( BOOL success, NSError *error )
|
|
|
+ {
|
|
|
+ if( success )
|
|
|
+ {
|
|
|
+ [[NSFileManager defaultManager] removeItemAtPath:path error:nil];
|
|
|
+ UnitySendMessage( "NGMediaSaveCallbackiOS", "OnMediaSaveCompleted", "" );
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ NSLog( @"Error creating asset in default Photos album: %@", error );
|
|
|
+
|
|
|
+ UIImage *image = [UIImage imageWithContentsOfFile:path];
|
|
|
+ if( image != nil )
|
|
|
+ UIImageWriteToSavedPhotosAlbum( image, self, @selector(image:didFinishSavingWithError:contextInfo:), (__bridge_retained void *) path );
|
|
|
+ else
|
|
|
+ {
|
|
|
+ NSLog( @"Couldn't create UIImage from file at path: %@", path );
|
|
|
+ [[NSFileManager defaultManager] removeItemAtPath:path error:nil];
|
|
|
+ UnitySendMessage( "NGMediaSaveCallbackiOS", "OnMediaSaveFailed", "" );
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }];
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ if( UIVideoAtPathIsCompatibleWithSavedPhotosAlbum( path ) )
|
|
|
+ UISaveVideoAtPathToSavedPhotosAlbum( path, self, @selector(video:didFinishSavingWithError:contextInfo:), (__bridge_retained void *) path );
|
|
|
+ else
|
|
|
+ {
|
|
|
+ NSLog( @"Video at path isn't compatible with saved photos album: %@", path );
|
|
|
+ [[NSFileManager defaultManager] removeItemAtPath:path error:nil];
|
|
|
+ UnitySendMessage( "NGMediaSaveCallbackiOS", "OnMediaSaveFailed", "" );
|
|
|
+ }
|
|
|
+ }
|
|
|
+ };
|
|
|
+
|
|
|
+ void (^saveBlock)(PHAssetCollection *assetCollection) = ^void( PHAssetCollection *assetCollection )
|
|
|
+ {
|
|
|
+ [[PHPhotoLibrary sharedPhotoLibrary] performChanges:
|
|
|
+ ^{
|
|
|
+ PHAssetChangeRequest *assetChangeRequest;
|
|
|
+ if( isImage )
|
|
|
+ assetChangeRequest = [PHAssetChangeRequest creationRequestForAssetFromImageAtFileURL:[NSURL fileURLWithPath:path]];
|
|
|
+ else
|
|
|
+ assetChangeRequest = [PHAssetChangeRequest creationRequestForAssetFromVideoAtFileURL:[NSURL fileURLWithPath:path]];
|
|
|
+
|
|
|
+ PHAssetCollectionChangeRequest *assetCollectionChangeRequest = [PHAssetCollectionChangeRequest changeRequestForAssetCollection:assetCollection];
|
|
|
+ [assetCollectionChangeRequest addAssets:@[[assetChangeRequest placeholderForCreatedAsset]]];
|
|
|
+
|
|
|
+ }
|
|
|
+ completionHandler:^( BOOL success, NSError *error )
|
|
|
+ {
|
|
|
+ if( success )
|
|
|
+ {
|
|
|
+ [[NSFileManager defaultManager] removeItemAtPath:path error:nil];
|
|
|
+ UnitySendMessage( "NGMediaSaveCallbackiOS", "OnMediaSaveCompleted", "" );
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ NSLog( @"Error creating asset: %@", error );
|
|
|
+ saveToPhotosAlbum();
|
|
|
+ }
|
|
|
+ }];
|
|
|
+ };
|
|
|
+
|
|
|
+ if( saveToDefaultAlbum )
|
|
|
+ saveToPhotosAlbum();
|
|
|
+ else
|
|
|
+ {
|
|
|
+ PHFetchOptions *fetchOptions = [[PHFetchOptions alloc] init];
|
|
|
+ fetchOptions.predicate = [NSPredicate predicateWithFormat:@"localizedTitle = %@", album];
|
|
|
+ PHFetchResult *fetchResult = [PHAssetCollection fetchAssetCollectionsWithType:PHAssetCollectionTypeAlbum subtype:PHAssetCollectionSubtypeAny options:fetchOptions];
|
|
|
+ if( fetchResult.count > 0 )
|
|
|
+ saveBlock( fetchResult.firstObject);
|
|
|
+ else
|
|
|
+ {
|
|
|
+ __block PHObjectPlaceholder *albumPlaceholder;
|
|
|
+ [[PHPhotoLibrary sharedPhotoLibrary] performChanges:
|
|
|
+ ^{
|
|
|
+ PHAssetCollectionChangeRequest *changeRequest = [PHAssetCollectionChangeRequest creationRequestForAssetCollectionWithTitle:album];
|
|
|
+ albumPlaceholder = changeRequest.placeholderForCreatedAssetCollection;
|
|
|
+ }
|
|
|
+ completionHandler:^( BOOL success, NSError *error )
|
|
|
+ {
|
|
|
+ if( success )
|
|
|
+ {
|
|
|
+ PHFetchResult *fetchResult = [PHAssetCollection fetchAssetCollectionsWithLocalIdentifiers:@[albumPlaceholder.localIdentifier] options:nil];
|
|
|
+ if( fetchResult.count > 0 )
|
|
|
+ saveBlock( fetchResult.firstObject);
|
|
|
+ else
|
|
|
+ {
|
|
|
+ NSLog( @"Error creating album: Album placeholder not found" );
|
|
|
+ saveToPhotosAlbum();
|
|
|
+ }
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ NSLog( @"Error creating album: %@", error );
|
|
|
+ saveToPhotosAlbum();
|
|
|
+ }
|
|
|
+ }];
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
++ (void)image:(UIImage *)image didFinishSavingWithError:(NSError *)error contextInfo:(void *)contextInfo
|
|
|
+{
|
|
|
+ NSString* path = (__bridge_transfer NSString *)(contextInfo);
|
|
|
+ [[NSFileManager defaultManager] removeItemAtPath:path error:nil];
|
|
|
+
|
|
|
+ if( error == nil )
|
|
|
+ UnitySendMessage( "NGMediaSaveCallbackiOS", "OnMediaSaveCompleted", "" );
|
|
|
+ else
|
|
|
+ {
|
|
|
+ NSLog( @"Error saving image with UIImageWriteToSavedPhotosAlbum: %@", error );
|
|
|
+ UnitySendMessage( "NGMediaSaveCallbackiOS", "OnMediaSaveFailed", "" );
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
++ (void)video:(NSString *)videoPath didFinishSavingWithError:(NSError *)error contextInfo:(void *)contextInfo
|
|
|
+{
|
|
|
+ NSString* path = (__bridge_transfer NSString *)(contextInfo);
|
|
|
+ [[NSFileManager defaultManager] removeItemAtPath:path error:nil];
|
|
|
+
|
|
|
+ if( error == nil )
|
|
|
+ UnitySendMessage( "NGMediaSaveCallbackiOS", "OnMediaSaveCompleted", "" );
|
|
|
+ else
|
|
|
+ {
|
|
|
+ NSLog( @"Error saving video with UISaveVideoAtPathToSavedPhotosAlbum: %@", error );
|
|
|
+ UnitySendMessage( "NGMediaSaveCallbackiOS", "OnMediaSaveFailed", "" );
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+// Credit: https://stackoverflow.com/a/10531752/2373034
|
|
|
++ (void)pickMedia:(int)mediaType savePath:(NSString *)mediaSavePath permissionFreeMode:(BOOL)permissionFreeMode selectionLimit:(int)selectionLimit
|
|
|
+{
|
|
|
+ pickedMediaSavePath = mediaSavePath;
|
|
|
+ imagePickerState = 1;
|
|
|
+ simpleMediaPickMode = permissionFreeMode && CHECK_IOS_VERSION( @"11.0" );
|
|
|
+
|
|
|
+#if __IPHONE_OS_VERSION_MAX_ALLOWED >= 140000
|
|
|
+ if( CHECK_IOS_VERSION( @"14.0" ) )
|
|
|
+ {
|
|
|
+ // PHPickerViewController is used on iOS 14
|
|
|
+ PHPickerConfiguration *config = simpleMediaPickMode ? [[PHPickerConfiguration alloc] init] : [[PHPickerConfiguration alloc] initWithPhotoLibrary:[PHPhotoLibrary sharedPhotoLibrary]];
|
|
|
+ config.preferredAssetRepresentationMode = PHPickerConfigurationAssetRepresentationModeCurrent;
|
|
|
+ config.selectionLimit = selectionLimit;
|
|
|
+ pickingMultipleFiles = selectionLimit != 1;
|
|
|
+
|
|
|
+ // mediaType is a bitmask:
|
|
|
+ // 1: image
|
|
|
+ // 2: video
|
|
|
+ // 4: audio (not supported)
|
|
|
+ if( mediaType == 1 )
|
|
|
+ config.filter = [PHPickerFilter anyFilterMatchingSubfilters:[NSArray arrayWithObjects:[PHPickerFilter imagesFilter], [PHPickerFilter livePhotosFilter], nil]];
|
|
|
+ else if( mediaType == 2 )
|
|
|
+ config.filter = [PHPickerFilter videosFilter];
|
|
|
+ else
|
|
|
+ config.filter = [PHPickerFilter anyFilterMatchingSubfilters:[NSArray arrayWithObjects:[PHPickerFilter imagesFilter], [PHPickerFilter livePhotosFilter], [PHPickerFilter videosFilter], nil]];
|
|
|
+
|
|
|
+ imagePickerNew = [[PHPickerViewController alloc] initWithConfiguration:config];
|
|
|
+ imagePickerNew.delegate = (id) self;
|
|
|
+ [UnityGetGLViewController() presentViewController:imagePickerNew animated:YES completion:^{ imagePickerState = 0; }];
|
|
|
+ }
|
|
|
+ else
|
|
|
+#endif
|
|
|
+ {
|
|
|
+ // UIImagePickerController is used on previous versions
|
|
|
+ imagePicker = [[UIImagePickerController alloc] init];
|
|
|
+ imagePicker.delegate = (id) self;
|
|
|
+ imagePicker.allowsEditing = NO;
|
|
|
+ imagePicker.sourceType = UIImagePickerControllerSourceTypePhotoLibrary;
|
|
|
+
|
|
|
+ // mediaType is a bitmask:
|
|
|
+ // 1: image
|
|
|
+ // 2: video
|
|
|
+ // 4: audio (not supported)
|
|
|
+ if( mediaType == 1 )
|
|
|
+ {
|
|
|
+ if( CHECK_IOS_VERSION( @"9.1" ) )
|
|
|
+ imagePicker.mediaTypes = [NSArray arrayWithObjects:(NSString *)kUTTypeImage, (NSString *)kUTTypeLivePhoto, nil];
|
|
|
+ else
|
|
|
+ imagePicker.mediaTypes = [NSArray arrayWithObject:(NSString *)kUTTypeImage];
|
|
|
+ }
|
|
|
+ else if( mediaType == 2 )
|
|
|
+ imagePicker.mediaTypes = [NSArray arrayWithObjects:(NSString *)kUTTypeMovie, (NSString *)kUTTypeVideo, nil];
|
|
|
+ else
|
|
|
+ {
|
|
|
+ if( CHECK_IOS_VERSION( @"9.1" ) )
|
|
|
+ imagePicker.mediaTypes = [NSArray arrayWithObjects:(NSString *)kUTTypeImage, (NSString *)kUTTypeLivePhoto, (NSString *)kUTTypeMovie, (NSString *)kUTTypeVideo, nil];
|
|
|
+ else
|
|
|
+ imagePicker.mediaTypes = [NSArray arrayWithObjects:(NSString *)kUTTypeImage, (NSString *)kUTTypeMovie, (NSString *)kUTTypeVideo, nil];
|
|
|
+ }
|
|
|
+
|
|
|
+#if __IPHONE_OS_VERSION_MAX_ALLOWED >= 110000
|
|
|
+ if( mediaType != 1 )
|
|
|
+ {
|
|
|
+ // Don't compress picked videos if possible
|
|
|
+ if( CHECK_IOS_VERSION( @"11.0" ) )
|
|
|
+ imagePicker.videoExportPreset = AVAssetExportPresetPassthrough;
|
|
|
+ }
|
|
|
+#endif
|
|
|
+
|
|
|
+ UIViewController *rootViewController = UnityGetGLViewController();
|
|
|
+ if( UI_USER_INTERFACE_IDIOM() == UIUserInterfaceIdiomPhone ) // iPhone
|
|
|
+ [rootViewController presentViewController:imagePicker animated:YES completion:^{ imagePickerState = 0; }];
|
|
|
+ else
|
|
|
+ {
|
|
|
+ // iPad
|
|
|
+ popup = [[UIPopoverController alloc] initWithContentViewController:imagePicker];
|
|
|
+ popup.delegate = (id) self;
|
|
|
+ [popup presentPopoverFromRect:CGRectMake( rootViewController.view.frame.size.width / 2, rootViewController.view.frame.size.height / 2, 1, 1 ) inView:rootViewController.view permittedArrowDirections:0 animated:YES];
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
++ (int)isMediaPickerBusy
|
|
|
+{
|
|
|
+ if( imagePickerState == 2 )
|
|
|
+ return 1;
|
|
|
+
|
|
|
+ if( imagePicker != nil )
|
|
|
+ {
|
|
|
+ if( imagePickerState == 1 || [imagePicker presentingViewController] == UnityGetGLViewController() )
|
|
|
+ return 1;
|
|
|
+ else
|
|
|
+ {
|
|
|
+ imagePicker = nil;
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+ }
|
|
|
+#if __IPHONE_OS_VERSION_MAX_ALLOWED >= 140000
|
|
|
+ else if( CHECK_IOS_VERSION( @"14.0" ) && imagePickerNew != nil )
|
|
|
+ {
|
|
|
+ if( imagePickerState == 1 || [imagePickerNew presentingViewController] == UnityGetGLViewController() )
|
|
|
+ return 1;
|
|
|
+ else
|
|
|
+ {
|
|
|
+ imagePickerNew = nil;
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+ }
|
|
|
+#endif
|
|
|
+ else
|
|
|
+ return 0;
|
|
|
+}
|
|
|
+
|
|
|
+#pragma clang diagnostic push
|
|
|
+#pragma clang diagnostic ignored "-Wdeprecated-declarations"
|
|
|
++ (void)imagePickerController:(UIImagePickerController *)picker didFinishPickingMediaWithInfo:(NSDictionary *)info
|
|
|
+{
|
|
|
+ NSString *resultPath = nil;
|
|
|
+
|
|
|
+ if( [info[UIImagePickerControllerMediaType] isEqualToString:(NSString *)kUTTypeImage] )
|
|
|
+ {
|
|
|
+ NSLog( @"Picked an image" );
|
|
|
+
|
|
|
+ // On iOS 8.0 or later, try to obtain the raw data of the image (which allows picking gifs properly or preserving metadata)
|
|
|
+ if( CHECK_IOS_VERSION( @"8.0" ) )
|
|
|
+ {
|
|
|
+ PHAsset *asset = nil;
|
|
|
+#if __IPHONE_OS_VERSION_MAX_ALLOWED >= 110000
|
|
|
+ if( CHECK_IOS_VERSION( @"11.0" ) )
|
|
|
+ {
|
|
|
+ // Try fetching the source image via UIImagePickerControllerImageURL
|
|
|
+ NSURL *mediaUrl = info[UIImagePickerControllerImageURL];
|
|
|
+ if( mediaUrl != nil )
|
|
|
+ {
|
|
|
+ NSString *imagePath = [mediaUrl path];
|
|
|
+ if( imagePath != nil && [[NSFileManager defaultManager] fileExistsAtPath:imagePath] )
|
|
|
+ {
|
|
|
+ NSError *error;
|
|
|
+ NSString *newPath = [pickedMediaSavePath stringByAppendingPathExtension:[imagePath pathExtension]];
|
|
|
+
|
|
|
+ if( ![[NSFileManager defaultManager] fileExistsAtPath:newPath] || [[NSFileManager defaultManager] removeItemAtPath:newPath error:&error] )
|
|
|
+ {
|
|
|
+ if( [[NSFileManager defaultManager] copyItemAtPath:imagePath toPath:newPath error:&error] )
|
|
|
+ {
|
|
|
+ resultPath = newPath;
|
|
|
+ NSLog( @"Copied source image from UIImagePickerControllerImageURL" );
|
|
|
+ }
|
|
|
+ else
|
|
|
+ NSLog( @"Error copying image: %@", error );
|
|
|
+ }
|
|
|
+ else
|
|
|
+ NSLog( @"Error deleting existing image: %@", error );
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ if( resultPath == nil )
|
|
|
+ asset = info[UIImagePickerControllerPHAsset];
|
|
|
+ }
|
|
|
+#endif
|
|
|
+
|
|
|
+ if( resultPath == nil && !simpleMediaPickMode )
|
|
|
+ {
|
|
|
+ if( asset == nil )
|
|
|
+ {
|
|
|
+ NSURL *mediaUrl = info[UIImagePickerControllerReferenceURL] ?: info[UIImagePickerControllerMediaURL];
|
|
|
+ if( mediaUrl != nil )
|
|
|
+ asset = [[PHAsset fetchAssetsWithALAssetURLs:[NSArray arrayWithObject:mediaUrl] options:nil] firstObject];
|
|
|
+ }
|
|
|
+
|
|
|
+ resultPath = [self trySavePHAsset:asset atIndex:1];
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ if( resultPath == nil )
|
|
|
+ {
|
|
|
+ // Save image as PNG
|
|
|
+ UIImage *image = info[UIImagePickerControllerOriginalImage];
|
|
|
+ if( image != nil )
|
|
|
+ {
|
|
|
+ resultPath = [pickedMediaSavePath stringByAppendingPathExtension:@"png"];
|
|
|
+ if( ![self saveImageAsPNG:image toPath:resultPath] )
|
|
|
+ {
|
|
|
+ NSLog( @"Error creating PNG image" );
|
|
|
+ resultPath = nil;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ else
|
|
|
+ NSLog( @"Error fetching original image from picker" );
|
|
|
+ }
|
|
|
+ }
|
|
|
+ else if( CHECK_IOS_VERSION( @"9.1" ) && [info[UIImagePickerControllerMediaType] isEqualToString:(NSString *)kUTTypeLivePhoto] )
|
|
|
+ {
|
|
|
+ NSLog( @"Picked a live photo" );
|
|
|
+
|
|
|
+ // Save live photo as PNG
|
|
|
+ UIImage *image = info[UIImagePickerControllerOriginalImage];
|
|
|
+ if( image != nil )
|
|
|
+ {
|
|
|
+ resultPath = [pickedMediaSavePath stringByAppendingPathExtension:@"png"];
|
|
|
+ if( ![self saveImageAsPNG:image toPath:resultPath] )
|
|
|
+ {
|
|
|
+ NSLog( @"Error creating PNG image" );
|
|
|
+ resultPath = nil;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ else
|
|
|
+ NSLog( @"Error fetching live photo's still image from picker" );
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ NSLog( @"Picked a video" );
|
|
|
+
|
|
|
+ NSURL *mediaUrl = info[UIImagePickerControllerMediaURL] ?: info[UIImagePickerControllerReferenceURL];
|
|
|
+ if( mediaUrl != nil )
|
|
|
+ {
|
|
|
+ resultPath = [mediaUrl path];
|
|
|
+
|
|
|
+ // On iOS 13, picked file becomes unreachable as soon as the UIImagePickerController disappears,
|
|
|
+ // in that case, copy the video to a temporary location
|
|
|
+ if( CHECK_IOS_VERSION( @"13.0" ) )
|
|
|
+ {
|
|
|
+ NSError *error;
|
|
|
+ NSString *newPath = [pickedMediaSavePath stringByAppendingPathExtension:[resultPath pathExtension]];
|
|
|
+
|
|
|
+ if( ![[NSFileManager defaultManager] fileExistsAtPath:newPath] || [[NSFileManager defaultManager] removeItemAtPath:newPath error:&error] )
|
|
|
+ {
|
|
|
+ if( [[NSFileManager defaultManager] copyItemAtPath:resultPath toPath:newPath error:&error] )
|
|
|
+ resultPath = newPath;
|
|
|
+ else
|
|
|
+ {
|
|
|
+ NSLog( @"Error copying video: %@", error );
|
|
|
+ resultPath = nil;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ NSLog( @"Error deleting existing video: %@", error );
|
|
|
+ resultPath = nil;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ popup = nil;
|
|
|
+ imagePicker = nil;
|
|
|
+ imagePickerState = 2;
|
|
|
+ UnitySendMessage( "NGMediaReceiveCallbackiOS", "OnMediaReceived", [self getCString:resultPath] );
|
|
|
+
|
|
|
+ [picker dismissViewControllerAnimated:NO completion:nil];
|
|
|
+}
|
|
|
+#pragma clang diagnostic pop
|
|
|
+
|
|
|
+#if __IPHONE_OS_VERSION_MAX_ALLOWED >= 140000
|
|
|
+// Credit: https://ikyle.me/blog/2020/phpickerviewcontroller
|
|
|
++(void)picker:(PHPickerViewController *)picker didFinishPicking:(NSArray<PHPickerResult *> *)results
|
|
|
+{
|
|
|
+ imagePickerNew = nil;
|
|
|
+ imagePickerState = 2;
|
|
|
+
|
|
|
+ [picker dismissViewControllerAnimated:NO completion:nil];
|
|
|
+
|
|
|
+ if( results != nil && [results count] > 0 )
|
|
|
+ {
|
|
|
+ NSMutableArray<NSString *> *resultPaths = [NSMutableArray arrayWithCapacity:[results count]];
|
|
|
+ NSLock *arrayLock = [[NSLock alloc] init];
|
|
|
+ dispatch_group_t group = dispatch_group_create();
|
|
|
+
|
|
|
+ for( int i = 0; i < [results count]; i++ )
|
|
|
+ {
|
|
|
+ PHPickerResult *result = results[i];
|
|
|
+ NSItemProvider *itemProvider = result.itemProvider;
|
|
|
+ NSString *assetIdentifier = result.assetIdentifier;
|
|
|
+ __block NSString *resultPath = nil;
|
|
|
+
|
|
|
+ int j = i + 1;
|
|
|
+
|
|
|
+ //NSLog( @"result: %@", result );
|
|
|
+ //NSLog( @"%@", result.assetIdentifier);
|
|
|
+ //NSLog( @"%@", result.itemProvider);
|
|
|
+
|
|
|
+ if( [itemProvider hasItemConformingToTypeIdentifier:(NSString *)kUTTypeImage] )
|
|
|
+ {
|
|
|
+ NSLog( @"Picked an image" );
|
|
|
+
|
|
|
+ if( !simpleMediaPickMode && assetIdentifier != nil )
|
|
|
+ {
|
|
|
+ PHAsset *asset = [[PHAsset fetchAssetsWithLocalIdentifiers:[NSArray arrayWithObject:assetIdentifier] options:nil] firstObject];
|
|
|
+ resultPath = [self trySavePHAsset:asset atIndex:j];
|
|
|
+ }
|
|
|
+
|
|
|
+ if( resultPath != nil )
|
|
|
+ {
|
|
|
+ [arrayLock lock];
|
|
|
+ [resultPaths addObject:resultPath];
|
|
|
+ [arrayLock unlock];
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ dispatch_group_enter( group );
|
|
|
+
|
|
|
+ [itemProvider loadFileRepresentationForTypeIdentifier:(NSString *)kUTTypeImage completionHandler:^( NSURL *url, NSError *error )
|
|
|
+ {
|
|
|
+ if( url != nil )
|
|
|
+ {
|
|
|
+ // Copy the image to a temporary location because the returned image will be deleted by the OS after this callback is completed
|
|
|
+ resultPath = [url path];
|
|
|
+ NSString *newPath = [[NSString stringWithFormat:@"%@%d", pickedMediaSavePath, j] stringByAppendingPathExtension:[resultPath pathExtension]];
|
|
|
+
|
|
|
+ if( ![[NSFileManager defaultManager] fileExistsAtPath:newPath] || [[NSFileManager defaultManager] removeItemAtPath:newPath error:&error] )
|
|
|
+ {
|
|
|
+ if( [[NSFileManager defaultManager] copyItemAtPath:resultPath toPath:newPath error:&error])
|
|
|
+ resultPath = newPath;
|
|
|
+ else
|
|
|
+ {
|
|
|
+ NSLog( @"Error copying image: %@", error );
|
|
|
+ resultPath = nil;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ NSLog( @"Error deleting existing image: %@", error );
|
|
|
+ resultPath = nil;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ else
|
|
|
+ NSLog( @"Error getting the picked image's path: %@", error );
|
|
|
+
|
|
|
+ if( resultPath != nil )
|
|
|
+ {
|
|
|
+ [arrayLock lock];
|
|
|
+ [resultPaths addObject:resultPath];
|
|
|
+ [arrayLock unlock];
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ if( [itemProvider canLoadObjectOfClass:[UIImage class]] )
|
|
|
+ {
|
|
|
+ dispatch_group_enter( group );
|
|
|
+
|
|
|
+ [itemProvider loadObjectOfClass:[UIImage class] completionHandler:^( __kindof id<NSItemProviderReading> object, NSError *error )
|
|
|
+ {
|
|
|
+ if( object != nil && [object isKindOfClass:[UIImage class]] )
|
|
|
+ {
|
|
|
+ resultPath = [[NSString stringWithFormat:@"%@%d", pickedMediaSavePath, j] stringByAppendingPathExtension:@"png"];
|
|
|
+ if( ![self saveImageAsPNG:(UIImage *)object toPath:resultPath] )
|
|
|
+ {
|
|
|
+ NSLog( @"Error creating PNG image" );
|
|
|
+ resultPath = nil;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ else
|
|
|
+ NSLog( @"Error generating UIImage from picked image: %@", error );
|
|
|
+
|
|
|
+ [arrayLock lock];
|
|
|
+ [resultPaths addObject:( resultPath != nil ? resultPath : @"" )];
|
|
|
+ [arrayLock unlock];
|
|
|
+
|
|
|
+ dispatch_group_leave( group );
|
|
|
+ }];
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ NSLog( @"Can't generate UIImage from picked image" );
|
|
|
+
|
|
|
+ [arrayLock lock];
|
|
|
+ [resultPaths addObject:@""];
|
|
|
+ [arrayLock unlock];
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ dispatch_group_leave( group );
|
|
|
+ }];
|
|
|
+ }
|
|
|
+ }
|
|
|
+ else if( CHECK_IOS_VERSION( @"9.1" ) && [itemProvider hasItemConformingToTypeIdentifier:(NSString *)kUTTypeLivePhoto] )
|
|
|
+ {
|
|
|
+ NSLog( @"Picked a live photo" );
|
|
|
+
|
|
|
+ if( [itemProvider canLoadObjectOfClass:[UIImage class]] )
|
|
|
+ {
|
|
|
+ dispatch_group_enter( group );
|
|
|
+
|
|
|
+ [itemProvider loadObjectOfClass:[UIImage class] completionHandler:^( __kindof id<NSItemProviderReading> object, NSError *error )
|
|
|
+ {
|
|
|
+ if( object != nil && [object isKindOfClass:[UIImage class]] )
|
|
|
+ {
|
|
|
+ resultPath = [[NSString stringWithFormat:@"%@%d", pickedMediaSavePath, j] stringByAppendingPathExtension:@"png"];
|
|
|
+ if( ![self saveImageAsPNG:(UIImage *)object toPath:resultPath] )
|
|
|
+ {
|
|
|
+ NSLog( @"Error creating PNG image" );
|
|
|
+ resultPath = nil;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ else
|
|
|
+ NSLog( @"Error generating UIImage from picked live photo: %@", error );
|
|
|
+
|
|
|
+ [arrayLock lock];
|
|
|
+ [resultPaths addObject:( resultPath != nil ? resultPath : @"" )];
|
|
|
+ [arrayLock unlock];
|
|
|
+
|
|
|
+ dispatch_group_leave( group );
|
|
|
+ }];
|
|
|
+ }
|
|
|
+ else if( [itemProvider canLoadObjectOfClass:[PHLivePhoto class]] )
|
|
|
+ {
|
|
|
+ dispatch_group_enter( group );
|
|
|
+
|
|
|
+ [itemProvider loadObjectOfClass:[PHLivePhoto class] completionHandler:^( __kindof id<NSItemProviderReading> object, NSError *error )
|
|
|
+ {
|
|
|
+ if( object != nil && [object isKindOfClass:[PHLivePhoto class]] )
|
|
|
+ {
|
|
|
+ // Extract image data from live photo
|
|
|
+ // Credit: https://stackoverflow.com/a/41341675/2373034
|
|
|
+ NSArray<PHAssetResource*>* livePhotoResources = [PHAssetResource assetResourcesForLivePhoto:(PHLivePhoto *)object];
|
|
|
+
|
|
|
+ PHAssetResource *livePhotoImage = nil;
|
|
|
+ for( int k = 0; k < [livePhotoResources count]; k++ )
|
|
|
+ {
|
|
|
+ if( livePhotoResources[k].type == PHAssetResourceTypePhoto )
|
|
|
+ {
|
|
|
+ livePhotoImage = livePhotoResources[k];
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ if( livePhotoImage == nil )
|
|
|
+ {
|
|
|
+ NSLog( @"Error extracting image data from live photo" );
|
|
|
+
|
|
|
+ [arrayLock lock];
|
|
|
+ [resultPaths addObject:@""];
|
|
|
+ [arrayLock unlock];
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ dispatch_group_enter( group );
|
|
|
+
|
|
|
+ NSString *originalFilename = livePhotoImage.originalFilename;
|
|
|
+ if( originalFilename == nil || [originalFilename length] == 0 )
|
|
|
+ resultPath = [NSString stringWithFormat:@"%@%d", pickedMediaSavePath, j];
|
|
|
+ else
|
|
|
+ resultPath = [[NSString stringWithFormat:@"%@%d", pickedMediaSavePath, j] stringByAppendingPathExtension:[originalFilename pathExtension]];
|
|
|
+
|
|
|
+ [[PHAssetResourceManager defaultManager] writeDataForAssetResource:livePhotoImage toFile:[NSURL fileURLWithPath:resultPath] options:nil completionHandler:^( NSError * _Nullable error2 )
|
|
|
+ {
|
|
|
+ if( error2 != nil )
|
|
|
+ {
|
|
|
+ NSLog( @"Error saving image data from live photo: %@", error2 );
|
|
|
+ resultPath = nil;
|
|
|
+ }
|
|
|
+
|
|
|
+ [arrayLock lock];
|
|
|
+ [resultPaths addObject:( resultPath != nil ? resultPath : @"" )];
|
|
|
+ [arrayLock unlock];
|
|
|
+
|
|
|
+ dispatch_group_leave( group );
|
|
|
+ }];
|
|
|
+ }
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ NSLog( @"Error generating PHLivePhoto from picked live photo: %@", error );
|
|
|
+
|
|
|
+ [arrayLock lock];
|
|
|
+ [resultPaths addObject:@""];
|
|
|
+ [arrayLock unlock];
|
|
|
+ }
|
|
|
+
|
|
|
+ dispatch_group_leave( group );
|
|
|
+ }];
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ NSLog( @"Can't convert picked live photo to still image" );
|
|
|
+
|
|
|
+ [arrayLock lock];
|
|
|
+ [resultPaths addObject:@""];
|
|
|
+ [arrayLock unlock];
|
|
|
+ }
|
|
|
+ }
|
|
|
+ else if( [itemProvider hasItemConformingToTypeIdentifier:(NSString *)kUTTypeMovie] || [itemProvider hasItemConformingToTypeIdentifier:(NSString *)kUTTypeVideo] )
|
|
|
+ {
|
|
|
+ NSLog( @"Picked a video" );
|
|
|
+
|
|
|
+ // Get the video file's path
|
|
|
+ dispatch_group_enter( group );
|
|
|
+
|
|
|
+ [itemProvider loadFileRepresentationForTypeIdentifier:([itemProvider hasItemConformingToTypeIdentifier:(NSString *)kUTTypeMovie] ? (NSString *)kUTTypeMovie : (NSString *)kUTTypeVideo) completionHandler:^( NSURL *url, NSError *error )
|
|
|
+ {
|
|
|
+ if( url != nil )
|
|
|
+ {
|
|
|
+ // Copy the video to a temporary location because the returned video will be deleted by the OS after this callback is completed
|
|
|
+ resultPath = [url path];
|
|
|
+ NSString *newPath = [[NSString stringWithFormat:@"%@%d", pickedMediaSavePath, j] stringByAppendingPathExtension:[resultPath pathExtension]];
|
|
|
+
|
|
|
+ if( ![[NSFileManager defaultManager] fileExistsAtPath:newPath] || [[NSFileManager defaultManager] removeItemAtPath:newPath error:&error] )
|
|
|
+ {
|
|
|
+ if( [[NSFileManager defaultManager] copyItemAtPath:resultPath toPath:newPath error:&error])
|
|
|
+ resultPath = newPath;
|
|
|
+ else
|
|
|
+ {
|
|
|
+ NSLog( @"Error copying video: %@", error );
|
|
|
+ resultPath = nil;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ NSLog( @"Error deleting existing video: %@", error );
|
|
|
+ resultPath = nil;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ else
|
|
|
+ NSLog( @"Error getting the picked video's path: %@", error );
|
|
|
+
|
|
|
+ [arrayLock lock];
|
|
|
+ [resultPaths addObject:( resultPath != nil ? resultPath : @"" )];
|
|
|
+ [arrayLock unlock];
|
|
|
+
|
|
|
+ dispatch_group_leave( group );
|
|
|
+ }];
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ // Unknown media type picked?
|
|
|
+ NSLog( @"Couldn't determine type of picked media: %@", itemProvider );
|
|
|
+
|
|
|
+ [arrayLock lock];
|
|
|
+ [resultPaths addObject:@""];
|
|
|
+ [arrayLock unlock];
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ dispatch_group_notify( group, dispatch_get_main_queue(),
|
|
|
+ ^{
|
|
|
+ if( !pickingMultipleFiles )
|
|
|
+ UnitySendMessage( "NGMediaReceiveCallbackiOS", "OnMediaReceived", [self getCString:resultPaths[0]] );
|
|
|
+ else
|
|
|
+ UnitySendMessage( "NGMediaReceiveCallbackiOS", "OnMultipleMediaReceived", [self getCString:[resultPaths componentsJoinedByString:@">"]] );
|
|
|
+ });
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ NSLog( @"No media picked" );
|
|
|
+
|
|
|
+ if( !pickingMultipleFiles )
|
|
|
+ UnitySendMessage( "NGMediaReceiveCallbackiOS", "OnMediaReceived", "" );
|
|
|
+ else
|
|
|
+ UnitySendMessage( "NGMediaReceiveCallbackiOS", "OnMultipleMediaReceived", "" );
|
|
|
+ }
|
|
|
+}
|
|
|
+#endif
|
|
|
+
|
|
|
++ (void)imagePickerControllerDidCancel:(UIImagePickerController *)picker
|
|
|
+{
|
|
|
+ NSLog( @"UIImagePickerController cancelled" );
|
|
|
+
|
|
|
+ popup = nil;
|
|
|
+ imagePicker = nil;
|
|
|
+ UnitySendMessage( "NGMediaReceiveCallbackiOS", "OnMediaReceived", "" );
|
|
|
+
|
|
|
+ [picker dismissViewControllerAnimated:NO completion:nil];
|
|
|
+}
|
|
|
+
|
|
|
++ (void)popoverControllerDidDismissPopover:(UIPopoverController *)popoverController
|
|
|
+{
|
|
|
+ NSLog( @"UIPopoverController dismissed" );
|
|
|
+
|
|
|
+ popup = nil;
|
|
|
+ imagePicker = nil;
|
|
|
+ UnitySendMessage( "NGMediaReceiveCallbackiOS", "OnMediaReceived", "" );
|
|
|
+}
|
|
|
+
|
|
|
++ (NSString *)trySavePHAsset:(PHAsset *)asset atIndex:(int)filenameIndex
|
|
|
+{
|
|
|
+ if( asset == nil )
|
|
|
+ return nil;
|
|
|
+
|
|
|
+ __block NSString *resultPath = nil;
|
|
|
+
|
|
|
+ PHImageRequestOptions *options = [[PHImageRequestOptions alloc] init];
|
|
|
+ options.synchronous = YES;
|
|
|
+ options.version = PHImageRequestOptionsVersionCurrent;
|
|
|
+
|
|
|
+#if __IPHONE_OS_VERSION_MAX_ALLOWED >= 130000
|
|
|
+ if( CHECK_IOS_VERSION( @"13.0" ) )
|
|
|
+ {
|
|
|
+ [[PHImageManager defaultManager] requestImageDataAndOrientationForAsset:asset options:options resultHandler:^( NSData *imageData, NSString *dataUTI, CGImagePropertyOrientation orientation, NSDictionary *imageInfo )
|
|
|
+ {
|
|
|
+ if( imageData != nil )
|
|
|
+ resultPath = [self trySaveSourceImage:imageData withInfo:imageInfo atIndex:filenameIndex];
|
|
|
+ else
|
|
|
+ NSLog( @"Couldn't fetch raw image data" );
|
|
|
+ }];
|
|
|
+ }
|
|
|
+ else
|
|
|
+#endif
|
|
|
+ {
|
|
|
+ [[PHImageManager defaultManager] requestImageDataForAsset:asset options:options resultHandler:^( NSData *imageData, NSString *dataUTI, UIImageOrientation orientation, NSDictionary *imageInfo )
|
|
|
+ {
|
|
|
+ if( imageData != nil )
|
|
|
+ resultPath = [self trySaveSourceImage:imageData withInfo:imageInfo atIndex:filenameIndex];
|
|
|
+ else
|
|
|
+ NSLog( @"Couldn't fetch raw image data" );
|
|
|
+ }];
|
|
|
+ }
|
|
|
+
|
|
|
+ return resultPath;
|
|
|
+}
|
|
|
+
|
|
|
++ (NSString *)trySaveSourceImage:(NSData *)imageData withInfo:(NSDictionary *)info atIndex:(int)filenameIndex
|
|
|
+{
|
|
|
+ NSString *filePath = info[@"PHImageFileURLKey"];
|
|
|
+ if( filePath != nil ) // filePath can actually be an NSURL, convert it to NSString
|
|
|
+ filePath = [NSString stringWithFormat:@"%@", filePath];
|
|
|
+
|
|
|
+ if( filePath == nil || [filePath length] == 0 )
|
|
|
+ {
|
|
|
+ filePath = info[@"PHImageFileUTIKey"];
|
|
|
+ if( filePath != nil )
|
|
|
+ filePath = [NSString stringWithFormat:@"%@", filePath];
|
|
|
+ }
|
|
|
+
|
|
|
+ NSString *resultPath;
|
|
|
+ if( filePath == nil || [filePath length] == 0 )
|
|
|
+ resultPath = [NSString stringWithFormat:@"%@%d", pickedMediaSavePath, filenameIndex];
|
|
|
+ else
|
|
|
+ resultPath = [[NSString stringWithFormat:@"%@%d", pickedMediaSavePath, filenameIndex] stringByAppendingPathExtension:[filePath pathExtension]];
|
|
|
+
|
|
|
+ NSError *error;
|
|
|
+ if( ![[NSFileManager defaultManager] fileExistsAtPath:resultPath] || [[NSFileManager defaultManager] removeItemAtPath:resultPath error:&error] )
|
|
|
+ {
|
|
|
+ if( ![imageData writeToFile:resultPath atomically:YES] )
|
|
|
+ {
|
|
|
+ NSLog( @"Error copying source image to file" );
|
|
|
+ resultPath = nil;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ NSLog( @"Error deleting existing image: %@", error );
|
|
|
+ resultPath = nil;
|
|
|
+ }
|
|
|
+
|
|
|
+ return resultPath;
|
|
|
+}
|
|
|
+
|
|
|
+// Credit: https://lists.apple.com/archives/cocoa-dev/2012/Jan/msg00052.html
|
|
|
++ (int)getMediaTypeFromExtension:(NSString *)extension
|
|
|
+{
|
|
|
+ CFStringRef fileUTI = UTTypeCreatePreferredIdentifierForTag( kUTTagClassFilenameExtension, (__bridge CFStringRef) extension, NULL );
|
|
|
+
|
|
|
+ // mediaType is a bitmask:
|
|
|
+ // 1: image
|
|
|
+ // 2: video
|
|
|
+ // 4: audio (not supported)
|
|
|
+ int result = 0;
|
|
|
+ if( UTTypeConformsTo( fileUTI, kUTTypeImage ) )
|
|
|
+ result = 1;
|
|
|
+ else if( CHECK_IOS_VERSION( @"9.1" ) && UTTypeConformsTo( fileUTI, kUTTypeLivePhoto ) )
|
|
|
+ result = 1;
|
|
|
+ else if( UTTypeConformsTo( fileUTI, kUTTypeMovie ) || UTTypeConformsTo( fileUTI, kUTTypeVideo ) )
|
|
|
+ result = 2;
|
|
|
+ else if( UTTypeConformsTo( fileUTI, kUTTypeAudio ) )
|
|
|
+ result = 4;
|
|
|
+
|
|
|
+ CFRelease( fileUTI );
|
|
|
+
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+// Credit: https://stackoverflow.com/a/4170099/2373034
|
|
|
++ (NSArray *)getImageMetadata:(NSString *)path
|
|
|
+{
|
|
|
+ int width = 0;
|
|
|
+ int height = 0;
|
|
|
+ int orientation = -1;
|
|
|
+
|
|
|
+ CGImageSourceRef imageSource = CGImageSourceCreateWithURL( (__bridge CFURLRef) [NSURL fileURLWithPath:path], nil );
|
|
|
+ if( imageSource != nil )
|
|
|
+ {
|
|
|
+ NSDictionary *options = [NSDictionary dictionaryWithObject:[NSNumber numberWithBool:NO] forKey:(__bridge NSString *)kCGImageSourceShouldCache];
|
|
|
+ CFDictionaryRef imageProperties = CGImageSourceCopyPropertiesAtIndex( imageSource, 0, (__bridge CFDictionaryRef) options );
|
|
|
+ CFRelease( imageSource );
|
|
|
+
|
|
|
+ CGFloat widthF = 0.0f, heightF = 0.0f;
|
|
|
+ if( imageProperties != nil )
|
|
|
+ {
|
|
|
+ if( CFDictionaryContainsKey( imageProperties, kCGImagePropertyPixelWidth ) )
|
|
|
+ CFNumberGetValue( (CFNumberRef) CFDictionaryGetValue( imageProperties, kCGImagePropertyPixelWidth ), kCFNumberCGFloatType, &widthF );
|
|
|
+
|
|
|
+ if( CFDictionaryContainsKey( imageProperties, kCGImagePropertyPixelHeight ) )
|
|
|
+ CFNumberGetValue( (CFNumberRef) CFDictionaryGetValue( imageProperties, kCGImagePropertyPixelHeight ), kCFNumberCGFloatType, &heightF );
|
|
|
+
|
|
|
+ if( CFDictionaryContainsKey( imageProperties, kCGImagePropertyOrientation ) )
|
|
|
+ {
|
|
|
+ CFNumberGetValue( (CFNumberRef) CFDictionaryGetValue( imageProperties, kCGImagePropertyOrientation ), kCFNumberIntType, &orientation );
|
|
|
+
|
|
|
+ if( orientation > 4 )
|
|
|
+ {
|
|
|
+ // Landscape image
|
|
|
+ CGFloat temp = widthF;
|
|
|
+ widthF = heightF;
|
|
|
+ heightF = temp;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ CFRelease( imageProperties );
|
|
|
+ }
|
|
|
+
|
|
|
+ width = (int) roundf( widthF );
|
|
|
+ height = (int) roundf( heightF );
|
|
|
+ }
|
|
|
+
|
|
|
+ return [[NSArray alloc] initWithObjects:[NSNumber numberWithInt:width], [NSNumber numberWithInt:height], [NSNumber numberWithInt:orientation], nil];
|
|
|
+}
|
|
|
+
|
|
|
++ (char *)getImageProperties:(NSString *)path
|
|
|
+{
|
|
|
+ NSArray *metadata = [self getImageMetadata:path];
|
|
|
+
|
|
|
+ int orientationUnity;
|
|
|
+ int orientation = [metadata[2] intValue];
|
|
|
+
|
|
|
+ // To understand the magic numbers, see ImageOrientation enum in NativeGallery.cs
|
|
|
+ // and http://sylvana.net/jpegcrop/exif_orientation.html
|
|
|
+ if( orientation == 1 )
|
|
|
+ orientationUnity = 0;
|
|
|
+ else if( orientation == 2 )
|
|
|
+ orientationUnity = 4;
|
|
|
+ else if( orientation == 3 )
|
|
|
+ orientationUnity = 2;
|
|
|
+ else if( orientation == 4 )
|
|
|
+ orientationUnity = 6;
|
|
|
+ else if( orientation == 5 )
|
|
|
+ orientationUnity = 5;
|
|
|
+ else if( orientation == 6 )
|
|
|
+ orientationUnity = 1;
|
|
|
+ else if( orientation == 7 )
|
|
|
+ orientationUnity = 7;
|
|
|
+ else if( orientation == 8 )
|
|
|
+ orientationUnity = 3;
|
|
|
+ else
|
|
|
+ orientationUnity = -1;
|
|
|
+
|
|
|
+ return [self getCString:[NSString stringWithFormat:@"%d>%d> >%d", [metadata[0] intValue], [metadata[1] intValue], orientationUnity]];
|
|
|
+}
|
|
|
+
|
|
|
++ (char *)getVideoProperties:(NSString *)path
|
|
|
+{
|
|
|
+ CGSize size = CGSizeZero;
|
|
|
+ float rotation = 0;
|
|
|
+ long long duration = 0;
|
|
|
+
|
|
|
+ AVURLAsset *asset = [AVURLAsset URLAssetWithURL:[NSURL fileURLWithPath:path] options:nil];
|
|
|
+ if( asset != nil )
|
|
|
+ {
|
|
|
+ duration = (long long) round( CMTimeGetSeconds( [asset duration] ) * 1000 );
|
|
|
+ CGAffineTransform transform = [asset preferredTransform];
|
|
|
+ NSArray<AVAssetTrack *>* videoTracks = [asset tracksWithMediaType:AVMediaTypeVideo];
|
|
|
+ if( videoTracks != nil && [videoTracks count] > 0 )
|
|
|
+ {
|
|
|
+ size = [[videoTracks objectAtIndex:0] naturalSize];
|
|
|
+ transform = [[videoTracks objectAtIndex:0] preferredTransform];
|
|
|
+ }
|
|
|
+
|
|
|
+ rotation = atan2( transform.b, transform.a ) * ( 180.0 / M_PI );
|
|
|
+ }
|
|
|
+
|
|
|
+ return [self getCString:[NSString stringWithFormat:@"%d>%d>%lld>%f", (int) roundf( size.width ), (int) roundf( size.height ), duration, rotation]];
|
|
|
+}
|
|
|
+
|
|
|
++ (char *)getVideoThumbnail:(NSString *)path savePath:(NSString *)savePath maximumSize:(int)maximumSize captureTime:(double)captureTime
|
|
|
+{
|
|
|
+ AVAssetImageGenerator *thumbnailGenerator = [[AVAssetImageGenerator alloc] initWithAsset:[[AVURLAsset alloc] initWithURL:[NSURL fileURLWithPath:path] options:nil]];
|
|
|
+ thumbnailGenerator.appliesPreferredTrackTransform = YES;
|
|
|
+ thumbnailGenerator.maximumSize = CGSizeMake( (CGFloat) maximumSize, (CGFloat) maximumSize );
|
|
|
+ thumbnailGenerator.requestedTimeToleranceBefore = kCMTimeZero;
|
|
|
+ thumbnailGenerator.requestedTimeToleranceAfter = kCMTimeZero;
|
|
|
+
|
|
|
+ if( captureTime < 0.0 )
|
|
|
+ captureTime = 0.0;
|
|
|
+ else
|
|
|
+ {
|
|
|
+ AVURLAsset *asset = [AVURLAsset URLAssetWithURL:[NSURL fileURLWithPath:path] options:nil];
|
|
|
+ if( asset != nil )
|
|
|
+ {
|
|
|
+ double videoDuration = CMTimeGetSeconds( [asset duration] );
|
|
|
+ if( videoDuration > 0.0 && captureTime >= videoDuration - 0.1 )
|
|
|
+ {
|
|
|
+ if( captureTime > videoDuration )
|
|
|
+ captureTime = videoDuration;
|
|
|
+
|
|
|
+ thumbnailGenerator.requestedTimeToleranceBefore = CMTimeMakeWithSeconds( 1.0, 600 );
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ NSError *error = nil;
|
|
|
+ CGImageRef image = [thumbnailGenerator copyCGImageAtTime:CMTimeMakeWithSeconds( captureTime, 600 ) actualTime:nil error:&error];
|
|
|
+ if( image == nil )
|
|
|
+ {
|
|
|
+ if( error != nil )
|
|
|
+ NSLog( @"Error generating video thumbnail: %@", error );
|
|
|
+ else
|
|
|
+ NSLog( @"Error generating video thumbnail..." );
|
|
|
+
|
|
|
+ return [self getCString:@""];
|
|
|
+ }
|
|
|
+
|
|
|
+ UIImage *thumbnail = [[UIImage alloc] initWithCGImage:image];
|
|
|
+ CGImageRelease( image );
|
|
|
+
|
|
|
+ if( ![UIImagePNGRepresentation( thumbnail ) writeToFile:savePath atomically:YES] )
|
|
|
+ {
|
|
|
+ NSLog( @"Error saving thumbnail image" );
|
|
|
+ return [self getCString:@""];
|
|
|
+ }
|
|
|
+
|
|
|
+ return [self getCString:savePath];
|
|
|
+}
|
|
|
+
|
|
|
++ (BOOL)saveImageAsPNG:(UIImage *)image toPath:(NSString *)resultPath
|
|
|
+{
|
|
|
+ return [UIImagePNGRepresentation( [self scaleImage:image maxSize:16384] ) writeToFile:resultPath atomically:YES];
|
|
|
+}
|
|
|
+
|
|
|
++ (UIImage *)scaleImage:(UIImage *)image maxSize:(int)maxSize
|
|
|
+{
|
|
|
+ CGFloat width = image.size.width;
|
|
|
+ CGFloat height = image.size.height;
|
|
|
+
|
|
|
+ UIImageOrientation orientation = image.imageOrientation;
|
|
|
+ if( width <= maxSize && height <= maxSize && orientation != UIImageOrientationDown &&
|
|
|
+ orientation != UIImageOrientationLeft && orientation != UIImageOrientationRight &&
|
|
|
+ orientation != UIImageOrientationLeftMirrored && orientation != UIImageOrientationRightMirrored &&
|
|
|
+ orientation != UIImageOrientationUpMirrored && orientation != UIImageOrientationDownMirrored )
|
|
|
+ return image;
|
|
|
+
|
|
|
+ CGFloat scaleX = 1.0f;
|
|
|
+ CGFloat scaleY = 1.0f;
|
|
|
+ if( width > maxSize )
|
|
|
+ scaleX = maxSize / width;
|
|
|
+ if( height > maxSize )
|
|
|
+ scaleY = maxSize / height;
|
|
|
+
|
|
|
+ // Credit: https://github.com/mbcharbonneau/UIImage-Categories/blob/master/UIImage%2BAlpha.m
|
|
|
+ CGImageAlphaInfo alpha = CGImageGetAlphaInfo( image.CGImage );
|
|
|
+ BOOL hasAlpha = alpha == kCGImageAlphaFirst || alpha == kCGImageAlphaLast || alpha == kCGImageAlphaPremultipliedFirst || alpha == kCGImageAlphaPremultipliedLast;
|
|
|
+
|
|
|
+ CGFloat scaleRatio = scaleX < scaleY ? scaleX : scaleY;
|
|
|
+ CGRect imageRect = CGRectMake( 0, 0, width * scaleRatio, height * scaleRatio );
|
|
|
+
|
|
|
+#if __IPHONE_OS_VERSION_MAX_ALLOWED >= 100000
|
|
|
+ // Resize image with UIGraphicsImageRenderer (Apple's recommended API) if possible
|
|
|
+ if( CHECK_IOS_VERSION( @"10.0" ) )
|
|
|
+ {
|
|
|
+ UIGraphicsImageRendererFormat *format = [image imageRendererFormat];
|
|
|
+ format.opaque = !hasAlpha;
|
|
|
+ format.scale = image.scale;
|
|
|
+
|
|
|
+ UIGraphicsImageRenderer *renderer = [[UIGraphicsImageRenderer alloc] initWithSize:imageRect.size format:format];
|
|
|
+ image = [renderer imageWithActions:^( UIGraphicsImageRendererContext* _Nonnull myContext )
|
|
|
+ {
|
|
|
+ [image drawInRect:imageRect];
|
|
|
+ }];
|
|
|
+ }
|
|
|
+ else
|
|
|
+ #endif
|
|
|
+ {
|
|
|
+ UIGraphicsBeginImageContextWithOptions( imageRect.size, !hasAlpha, image.scale );
|
|
|
+ [image drawInRect:imageRect];
|
|
|
+ image = UIGraphicsGetImageFromCurrentImageContext();
|
|
|
+ UIGraphicsEndImageContext();
|
|
|
+ }
|
|
|
+
|
|
|
+ return image;
|
|
|
+}
|
|
|
+
|
|
|
++ (char *)loadImageAtPath:(NSString *)path tempFilePath:(NSString *)tempFilePath maximumSize:(int)maximumSize
|
|
|
+{
|
|
|
+ // Check if the image can be loaded by Unity without requiring a conversion to PNG
|
|
|
+ // Credit: https://stackoverflow.com/a/12048937/2373034
|
|
|
+ NSString *extension = [path pathExtension];
|
|
|
+ BOOL conversionNeeded = [extension caseInsensitiveCompare:@"jpg"] != NSOrderedSame && [extension caseInsensitiveCompare:@"jpeg"] != NSOrderedSame && [extension caseInsensitiveCompare:@"png"] != NSOrderedSame;
|
|
|
+
|
|
|
+ if( !conversionNeeded )
|
|
|
+ {
|
|
|
+ // Check if the image needs to be processed at all
|
|
|
+ NSArray *metadata = [self getImageMetadata:path];
|
|
|
+ int orientationInt = [metadata[2] intValue]; // 1: correct orientation, [1,8]: valid orientation range
|
|
|
+ if( orientationInt == 1 && [metadata[0] intValue] <= maximumSize && [metadata[1] intValue] <= maximumSize )
|
|
|
+ return [self getCString:path];
|
|
|
+ }
|
|
|
+
|
|
|
+ UIImage *image = [UIImage imageWithContentsOfFile:path];
|
|
|
+ if( image == nil )
|
|
|
+ return [self getCString:path];
|
|
|
+
|
|
|
+ UIImage *scaledImage = [self scaleImage:image maxSize:maximumSize];
|
|
|
+ if( conversionNeeded || scaledImage != image )
|
|
|
+ {
|
|
|
+ if( ![UIImagePNGRepresentation( scaledImage ) writeToFile:tempFilePath atomically:YES] )
|
|
|
+ {
|
|
|
+ NSLog( @"Error creating scaled image" );
|
|
|
+ return [self getCString:path];
|
|
|
+ }
|
|
|
+
|
|
|
+ return [self getCString:tempFilePath];
|
|
|
+ }
|
|
|
+ else
|
|
|
+ return [self getCString:path];
|
|
|
+}
|
|
|
+
|
|
|
+// Credit: https://stackoverflow.com/a/37052118/2373034
|
|
|
++ (char *)getCString:(NSString *)source
|
|
|
+{
|
|
|
+ if( source == nil )
|
|
|
+ source = @"";
|
|
|
+
|
|
|
+ const char *sourceUTF8 = [source UTF8String];
|
|
|
+ char *result = (char*) malloc( strlen( sourceUTF8 ) + 1 );
|
|
|
+ strcpy( result, sourceUTF8 );
|
|
|
+
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+@end
|
|
|
+
|
|
|
+extern "C" int _NativeGallery_CheckPermission( int readPermission, int permissionFreeMode )
|
|
|
+{
|
|
|
+ return [UNativeGallery checkPermission:( readPermission == 1 ) permissionFreeMode:( permissionFreeMode == 1 )];
|
|
|
+}
|
|
|
+
|
|
|
+extern "C" int _NativeGallery_RequestPermission( int readPermission, int permissionFreeMode, int asyncMode )
|
|
|
+{
|
|
|
+ return [UNativeGallery requestPermission:( readPermission == 1 ) permissionFreeMode:( permissionFreeMode == 1 ) asyncMode:( asyncMode == 1 )];
|
|
|
+}
|
|
|
+
|
|
|
+extern "C" void _NativeGallery_ShowLimitedLibraryPicker()
|
|
|
+{
|
|
|
+ return [UNativeGallery showLimitedLibraryPicker];
|
|
|
+}
|
|
|
+
|
|
|
+extern "C" int _NativeGallery_CanOpenSettings()
|
|
|
+{
|
|
|
+ return [UNativeGallery canOpenSettings];
|
|
|
+}
|
|
|
+
|
|
|
+extern "C" void _NativeGallery_OpenSettings()
|
|
|
+{
|
|
|
+ [UNativeGallery openSettings];
|
|
|
+}
|
|
|
+
|
|
|
+extern "C" int _NativeGallery_CanPickMultipleMedia()
|
|
|
+{
|
|
|
+ return [UNativeGallery canPickMultipleMedia];
|
|
|
+}
|
|
|
+
|
|
|
+extern "C" void _NativeGallery_ImageWriteToAlbum( const char* path, const char* album, int permissionFreeMode )
|
|
|
+{
|
|
|
+ [UNativeGallery saveMedia:[NSString stringWithUTF8String:path] albumName:[NSString stringWithUTF8String:album] isImg:YES permissionFreeMode:( permissionFreeMode == 1 )];
|
|
|
+}
|
|
|
+
|
|
|
+extern "C" void _NativeGallery_VideoWriteToAlbum( const char* path, const char* album, int permissionFreeMode )
|
|
|
+{
|
|
|
+ [UNativeGallery saveMedia:[NSString stringWithUTF8String:path] albumName:[NSString stringWithUTF8String:album] isImg:NO permissionFreeMode:( permissionFreeMode == 1 )];
|
|
|
+}
|
|
|
+
|
|
|
+extern "C" void _NativeGallery_PickMedia( const char* mediaSavePath, int mediaType, int permissionFreeMode, int selectionLimit )
|
|
|
+{
|
|
|
+ [UNativeGallery pickMedia:mediaType savePath:[NSString stringWithUTF8String:mediaSavePath] permissionFreeMode:( permissionFreeMode == 1 ) selectionLimit:selectionLimit];
|
|
|
+}
|
|
|
+
|
|
|
+extern "C" int _NativeGallery_IsMediaPickerBusy()
|
|
|
+{
|
|
|
+ return [UNativeGallery isMediaPickerBusy];
|
|
|
+}
|
|
|
+
|
|
|
+extern "C" int _NativeGallery_GetMediaTypeFromExtension( const char* extension )
|
|
|
+{
|
|
|
+ return [UNativeGallery getMediaTypeFromExtension:[NSString stringWithUTF8String:extension]];
|
|
|
+}
|
|
|
+
|
|
|
+extern "C" char* _NativeGallery_GetImageProperties( const char* path )
|
|
|
+{
|
|
|
+ return [UNativeGallery getImageProperties:[NSString stringWithUTF8String:path]];
|
|
|
+}
|
|
|
+
|
|
|
+extern "C" char* _NativeGallery_GetVideoProperties( const char* path )
|
|
|
+{
|
|
|
+ return [UNativeGallery getVideoProperties:[NSString stringWithUTF8String:path]];
|
|
|
+}
|
|
|
+
|
|
|
+extern "C" char* _NativeGallery_GetVideoThumbnail( const char* path, const char* thumbnailSavePath, int maxSize, double captureTimeInSeconds )
|
|
|
+{
|
|
|
+ return [UNativeGallery getVideoThumbnail:[NSString stringWithUTF8String:path] savePath:[NSString stringWithUTF8String:thumbnailSavePath] maximumSize:maxSize captureTime:captureTimeInSeconds];
|
|
|
+}
|
|
|
+
|
|
|
+extern "C" char* _NativeGallery_LoadImageAtPath( const char* path, const char* temporaryFilePath, int maxSize )
|
|
|
+{
|
|
|
+ return [UNativeGallery loadImageAtPath:[NSString stringWithUTF8String:path] tempFilePath:[NSString stringWithUTF8String:temporaryFilePath] maximumSize:maxSize];
|
|
|
+}
|
guodong