motorinc-gallery-picker-pro 1.0.0

package/ios/ImagePickerModule.m

@@ -0,0 +1,876 @@
+#import "ImagePickerModule.h"
+#import <React/RCTLog.h>
+#import <React/RCTUtils.h>
+#import <React/RCTBridge.h>
+#import <Photos/Photos.h>
+#import <AVFoundation/AVFoundation.h>
+#import <objc/message.h>
+#import <PhotosUI/PhotosUI.h>
+
+// Forward declare the method to avoid compiler warnings - remove this as it might be interfering
+// @interface PHPhotoLibrary (LimitedLibraryPicker)
+// - (void)presentLimitedLibraryPickerFromViewController:(UIViewController *)controller API_AVAILABLE(ios(14));
+// @end
+
+@interface ImagePickerModule() <PHPhotoLibraryChangeObserver>
+@property (nonatomic, strong) RCTPromiseResolveBlock resolve;
+@property (nonatomic, strong) RCTPromiseRejectBlock reject;
+@property (nonatomic, strong) NSDictionary *options;
+@end
+
+@implementation ImagePickerModule
+
+RCT_EXPORT_MODULE(ImagePickerModule);
+
++ (BOOL)requiresMainQueueSetup
+{
+    return YES;
+}
+
+- (NSArray<NSString *> *)supportedEvents
+{
+    return @[@"PhotoLibraryChanged"];
+}
+
+- (instancetype)init
+{
+    self = [super init];
+    if (self) {
+        // Register for photo library changes
+        [[PHPhotoLibrary sharedPhotoLibrary] registerChangeObserver:self];
+    }
+    return self;
+}
+
+- (void)dealloc
+{
+    [[PHPhotoLibrary sharedPhotoLibrary] unregisterChangeObserver:self];
+}
+
+RCT_EXPORT_METHOD(openCamera:(NSDictionary *)options
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+{
+    dispatch_async(dispatch_get_main_queue(), ^{
+        self.resolve = resolve;
+        self.reject = reject;
+        self.options = options;
+        
+        [self requestCameraPermissionWithCompletion:^(BOOL granted) {
+            if (granted) {
+                [self presentImagePickerWithSourceType:UIImagePickerControllerSourceTypeCamera];
+            } else {
+                reject(@"PERMISSION_DENIED", @"Camera permission not granted", nil);
+            }
+        }];
+    });
+}
+
+RCT_EXPORT_METHOD(openGallery:(NSDictionary *)options
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+{
+    dispatch_async(dispatch_get_main_queue(), ^{
+        self.resolve = resolve;
+        self.reject = reject;
+        self.options = options;
+        
+        [self requestGalleryPermissionWithCompletion:^(BOOL granted) {
+            if (granted) {
+                [self presentImagePickerWithSourceType:UIImagePickerControllerSourceTypePhotoLibrary];
+            } else {
+                reject(@"PERMISSION_DENIED", @"Photo library permission not granted", nil);
+            }
+        }];
+    });
+}
+
+RCT_EXPORT_METHOD(openMultiSelectGallery:(NSDictionary *)options
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+{
+    dispatch_async(dispatch_get_main_queue(), ^{
+        NSInteger maxSelectionLimit = options[@"maxSelectionLimit"] ? [options[@"maxSelectionLimit"] integerValue] : 10;
+        BOOL includeBase64 = options[@"includeBase64"] ? [options[@"includeBase64"] boolValue] : YES;
+        CGFloat quality = options[@"quality"] ? [options[@"quality"] floatValue] : 0.8;
+        
+        // Store for later use
+        NSMutableDictionary *multiSelectOptions = [NSMutableDictionary dictionaryWithDictionary:options];
+        multiSelectOptions[@"maxSelectionLimit"] = @(maxSelectionLimit);
+        multiSelectOptions[@"includeBase64"] = @(includeBase64);
+        multiSelectOptions[@"quality"] = @(quality);
+        multiSelectOptions[@"isMultiSelect"] = @(YES);
+        self.options = multiSelectOptions;
+        
+        // Store the promise for multi-select
+        self.resolve = resolve;
+        self.reject = reject;
+        
+        [self requestGalleryPermissionWithCompletion:^(BOOL granted) {
+            if (granted) {
+                [self presentMultiSelectPicker:maxSelectionLimit];
+            } else {
+                reject(@"PERMISSION_DENIED", @"Photo library permission not granted", nil);
+            }
+        }];
+    });
+}
+
+RCT_EXPORT_METHOD(requestCameraPermission:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+{
+    [self requestCameraPermissionWithCompletion:^(BOOL granted) {
+        resolve(@(granted));
+    }];
+}
+
+RCT_EXPORT_METHOD(requestGalleryPermission:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+{
+    dispatch_async(dispatch_get_main_queue(), ^{
+        [self requestGalleryPermissionWithCompletion:^(BOOL granted) {
+            resolve(@(granted));
+        }];
+    });
+}
+
+RCT_EXPORT_METHOD(getPhotoLibraryPermissionStatus:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+{
+    if (@available(iOS 14, *)) {
+        // For iOS 14+, check both read-write and add-only access levels
+        PHAuthorizationStatus readWriteStatus = [PHPhotoLibrary authorizationStatusForAccessLevel:PHAccessLevelReadWrite];
+        PHAuthorizationStatus addOnlyStatus = [PHPhotoLibrary authorizationStatusForAccessLevel:PHAccessLevelAddOnly];
+        
+        NSLog(@"📸 ReadWrite status: %ld, AddOnly status: %ld", (long)readWriteStatus, (long)addOnlyStatus);
+        
+        // Use readWrite status as primary
+        PHAuthorizationStatus status = readWriteStatus;
+        NSString *statusString;
+        
+        switch (status) {
+            case PHAuthorizationStatusAuthorized:
+                statusString = @"authorized";
+                NSLog(@"📸 Status: authorized (full access)");
+                break;
+            case PHAuthorizationStatusDenied:
+                statusString = @"denied";
+                NSLog(@"📸 Status: denied");
+                break;
+            case PHAuthorizationStatusRestricted:
+                statusString = @"restricted";
+                NSLog(@"📸 Status: restricted");
+                break;
+            case PHAuthorizationStatusNotDetermined:
+                statusString = @"not_determined";
+                NSLog(@"📸 Status: not_determined");
+                break;
+            case PHAuthorizationStatusLimited:
+                statusString = @"limited";
+                NSLog(@"📸 Status: limited (limited access detected)");
+                break;
+            default:
+                statusString = @"unknown";
+                NSLog(@"📸 Status: unknown (%ld)", (long)status);
+                break;
+        }
+        
+        // Double-check by also testing the legacy API
+        PHAuthorizationStatus legacyStatus = [PHPhotoLibrary authorizationStatus];
+        NSLog(@"📸 Legacy API status: %ld", (long)legacyStatus);
+        
+        // If legacy API shows limited, override
+        if (legacyStatus == PHAuthorizationStatusLimited) {
+            NSLog(@"📸 Legacy API detected limited access, overriding to limited");
+            statusString = @"limited";
+        }
+        
+        NSLog(@"📸 Final status string: %@", statusString);
+        resolve(statusString);
+    } else {
+        // iOS < 14 - use legacy method
+        PHAuthorizationStatus status = [PHPhotoLibrary authorizationStatus];
+        NSString *statusString;
+        
+        switch (status) {
+            case PHAuthorizationStatusAuthorized:
+                statusString = @"authorized";
+                break;
+            case PHAuthorizationStatusDenied:
+                statusString = @"denied";
+                break;
+            case PHAuthorizationStatusRestricted:
+                statusString = @"restricted";
+                break;
+            case PHAuthorizationStatusNotDetermined:
+                statusString = @"not_determined";
+                break;
+            default:
+                statusString = @"unknown";
+                break;
+        }
+        
+        resolve(statusString);
+    }
+}
+
+RCT_EXPORT_METHOD(fetchPhotoLibraryAssets:(NSDictionary *)options
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+{
+    dispatch_async(dispatch_get_main_queue(), ^{
+        NSInteger limit = options[@"limit"] ? [options[@"limit"] integerValue] : 20;
+        NSInteger offset = options[@"offset"] ? [options[@"offset"] integerValue] : 0;
+        NSString *mediaType = options[@"mediaType"] ? options[@"mediaType"] : @"photo";
+        
+        NSLog(@"Fetching assets with limit: %ld, offset: %ld, mediaType: %@", (long)limit, (long)offset, mediaType);
+        
+        // Check current authorization status
+        PHAuthorizationStatus status = [PHPhotoLibrary authorizationStatus];
+        NSLog(@"Current authorization status: %ld", (long)status);
+        
+        // For limited access, be more careful to avoid triggering popup
+        PHFetchOptions *fetchOptions = [[PHFetchOptions alloc] init];
+        fetchOptions.sortDescriptors = @[[NSSortDescriptor sortDescriptorWithKey:@"creationDate" ascending:NO]];
+        
+        // Configure media type based on parameter
+        PHAssetMediaType assetMediaType;
+        PHFetchResult<PHAsset *> *assets;
+        
+        if ([mediaType isEqualToString:@"video"]) {
+            assetMediaType = PHAssetMediaTypeVideo;
+            assets = [PHAsset fetchAssetsWithMediaType:assetMediaType options:fetchOptions];
+        } else if ([mediaType isEqualToString:@"mixed"]) {
+            // For mixed media, fetch all assets without specifying a media type
+            assets = [PHAsset fetchAssetsWithOptions:fetchOptions];
+        } else {
+            // Default to images
+            assetMediaType = PHAssetMediaTypeImage;
+            assets = [PHAsset fetchAssetsWithMediaType:assetMediaType options:fetchOptions];
+        }
+        
+        NSLog(@"Total assets found: %lu", (unsigned long)assets.count);
+        
+        if (assets.count == 0) {
+            resolve(@{
+                @"assets": @[],
+                @"hasMore": @NO,
+                @"totalCount": @0
+            });
+            return;
+        }
+        
+        NSInteger startIndex = offset;
+        NSInteger endIndex = MIN(offset + limit, assets.count);
+        NSInteger totalAssets = endIndex - startIndex;
+        
+        if (totalAssets <= 0) {
+            resolve(@{
+                @"assets": @[],
+                @"hasMore": @(offset < assets.count),
+                @"totalCount": @(assets.count)
+            });
+            return;
+        }
+        
+        NSMutableArray *assetArray = [[NSMutableArray alloc] init];
+        
+        // Use simpler approach - just return asset info without processing images
+        for (NSInteger i = startIndex; i < endIndex; i++) {
+            PHAsset *asset = [assets objectAtIndex:i];
+            
+            // Create a simple placeholder URI using the asset identifier
+            NSString *placeholderUri = [NSString stringWithFormat:@"ph://%@", asset.localIdentifier];
+            
+            // Determine asset media type
+            NSString *assetMediaTypeString;
+            if (asset.mediaType == PHAssetMediaTypeVideo) {
+                assetMediaTypeString = @"video";
+            } else {
+                assetMediaTypeString = @"image";
+            }
+            
+            NSMutableDictionary *assetInfo = [[NSMutableDictionary alloc] initWithDictionary:@{
+                @"uri": placeholderUri,
+                @"width": @(asset.pixelWidth),
+                @"height": @(asset.pixelHeight),
+                @"id": asset.localIdentifier,
+                @"creationDate": @([asset.creationDate timeIntervalSince1970] * 1000),
+                @"mediaType": assetMediaTypeString
+            }];
+            
+            // Add duration for videos
+            if (asset.mediaType == PHAssetMediaTypeVideo) {
+                assetInfo[@"duration"] = @(asset.duration);
+            }
+            
+            [assetArray addObject:assetInfo];
+        }
+        
+        // Sort by creation date
+        NSArray *sortedAssets = [assetArray sortedArrayUsingComparator:^NSComparisonResult(NSDictionary *a, NSDictionary *b) {
+            NSNumber *dateA = a[@"creationDate"];
+            NSNumber *dateB = b[@"creationDate"];
+            return [dateB compare:dateA];
+        }];
+        
+        BOOL hasMore = endIndex < assets.count;
+        
+        NSLog(@"Returning %lu assets, hasMore: %d, totalCount: %lu", 
+              (unsigned long)sortedAssets.count, hasMore, (unsigned long)assets.count);
+        
+        resolve(@{
+            @"assets": sortedAssets,
+            @"hasMore": @(hasMore),
+            @"totalCount": @(assets.count)
+        });
+    });
+}
+
+RCT_EXPORT_METHOD(getImageForAsset:(NSString *)assetId
+                  targetWidth:(NSNumber *)targetWidth
+                  targetHeight:(NSNumber *)targetHeight
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+{
+    dispatch_async(dispatch_get_main_queue(), ^{
+        PHFetchResult<PHAsset *> *result = [PHAsset fetchAssetsWithLocalIdentifiers:@[assetId] options:nil];
+        
+        if (result.count == 0) {
+            reject(@"ASSET_NOT_FOUND", @"Asset not found", nil);
+            return;
+        }
+        
+        PHAsset *asset = [result firstObject];
+        PHImageManager *imageManager = [PHImageManager defaultManager];
+        PHImageRequestOptions *requestOptions = [[PHImageRequestOptions alloc] init];
+        requestOptions.deliveryMode = PHImageRequestOptionsDeliveryModeHighQualityFormat;
+        requestOptions.networkAccessAllowed = YES;
+        requestOptions.synchronous = NO;
+        
+        CGFloat width = targetWidth ? [targetWidth floatValue] : 300;
+        CGFloat height = targetHeight ? [targetHeight floatValue] : 300;
+        
+        [imageManager requestImageForAsset:asset
+                                targetSize:CGSizeMake(width, height)
+                               contentMode:PHImageContentModeAspectFill
+                                   options:requestOptions
+                             resultHandler:^(UIImage *image, NSDictionary *info) {
+            if (image) {
+                NSData *imageData = UIImageJPEGRepresentation(image, 0.8);
+                NSString *fileName = [NSString stringWithFormat:@"asset_%@.jpg", [[NSUUID UUID] UUIDString]];
+                NSString *filePath = [NSTemporaryDirectory() stringByAppendingPathComponent:fileName];
+                
+                if ([imageData writeToFile:filePath atomically:YES]) {
+                    NSString *fileURI = [NSString stringWithFormat:@"file://%@", filePath];
+                    resolve(fileURI);
+                } else {
+                    reject(@"FILE_WRITE_ERROR", @"Failed to save image", nil);
+                }
+            } else {
+                reject(@"IMAGE_REQUEST_ERROR", @"Failed to get image", nil);
+            }
+        }];
+    });
+}
+
+RCT_EXPORT_METHOD(openPhotoLibraryLimitedPicker:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+{
+    NSLog(@"🚀 openPhotoLibraryLimitedPicker called - Limited photo management");
+    
+    dispatch_async(dispatch_get_main_queue(), ^{
+        UIViewController *presentingViewController = RCTPresentedViewController();
+        if (!presentingViewController) {
+            NSLog(@"❌ No presenting view controller available");
+            reject(@"NO_PRESENTING_VC", @"No presenting view controller available", nil);
+            return;
+        }
+        
+        // Check iOS version first
+        NSOperatingSystemVersion version = [[NSProcessInfo processInfo] operatingSystemVersion];
+        NSLog(@"📱 Running iOS %ld.%ld.%ld", (long)version.majorVersion, (long)version.minorVersion, (long)version.patchVersion);
+        
+        if (@available(iOS 15, *)) {
+            NSLog(@"✅ iOS 15+ detected - using presentLimitedLibraryPicker method");
+            
+            // Use the iOS 15+ method for modern photo library access
+            PHPhotoLibrary *photoLibrary = [PHPhotoLibrary sharedPhotoLibrary];
+            
+            // Check if the method exists
+            SEL pickerSelector = NSSelectorFromString(@"presentLimitedLibraryPickerFromViewController:completionHandler:");
+            
+            if ([photoLibrary respondsToSelector:pickerSelector]) {
+                NSLog(@"🎯 Presenting limited library picker with completion handler");
+                
+                // Use NSInvocation to call the method safely
+                NSMethodSignature *signature = [photoLibrary methodSignatureForSelector:pickerSelector];
+                NSInvocation *invocation = [NSInvocation invocationWithMethodSignature:signature];
+                [invocation setTarget:photoLibrary];
+                [invocation setSelector:pickerSelector];
+                [invocation setArgument:&presentingViewController atIndex:2];
+                
+                // Create completion handler block
+                void (^completionHandler)(NSArray<NSString *> *) = ^(NSArray<NSString *> *identifiers) {
+                    NSLog(@"✅ Limited library picker completed with %lu newly selected identifiers", (unsigned long)identifiers.count);
+                    
+                    // Trigger gallery refresh to show updated selection
+                    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(0.5 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
+                        [self sendEventWithName:@"PhotoLibraryChanged" body:@{}];
+                    });
+                };
+                
+                [invocation setArgument:&completionHandler atIndex:3];
+                [invocation invoke];
+                
+                NSLog(@"✅ Limited library picker should now be showing");
+                resolve(@{@"method": @"limited_picker", @"ios_version": @"15+"});
+                
+            } else {
+                NSLog(@"❌ Method not available even on iOS 15+");
+                // Fall back to settings
+                [self openSettingsApp:resolve reject:reject];
+            }
+            
+        } else if (@available(iOS 14, *)) {
+            NSLog(@"⚠️ iOS 14 detected - limited picker not available, using fallback");
+            // iOS 14 doesn't have presentLimitedLibraryPicker, fall back to settings
+            [self openSettingsApp:resolve reject:reject];
+            
+        } else {
+            NSLog(@"❌ iOS < 14, limited access not supported");
+            reject(@"IOS_VERSION_TOO_OLD", @"iOS 14+ required for limited photo access", nil);
+        }
+    });
+}
+
+- (void)openSettingsApp:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject
+{
+    NSLog(@"📱 Opening Settings app as fallback for photo management");
+    NSURL *settingsURL = [NSURL URLWithString:UIApplicationOpenSettingsURLString];
+    if ([[UIApplication sharedApplication] canOpenURL:settingsURL]) {
+        [[UIApplication sharedApplication] openURL:settingsURL options:@{} completionHandler:^(BOOL success) {
+            if (success) {
+                NSLog(@"✅ Settings app opened successfully");
+                resolve(@{@"method": @"settings_fallback"});
+            } else {
+                reject(@"SETTINGS_FAILED", @"Failed to open Settings app", nil);
+            }
+        }];
+    } else {
+        reject(@"SETTINGS_UNAVAILABLE", @"Cannot open Settings app", nil);
+    }
+}
+
+RCT_EXPORT_METHOD(openPhotoLibraryLimitedSettings:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+{
+    dispatch_async(dispatch_get_main_queue(), ^{
+        // This method always opens settings
+        [self openAppSettings:resolve];
+    });
+}
+
+- (void)openAppSettings:(RCTPromiseResolveBlock)resolve
+{
+    NSURL *settingsURL = [NSURL URLWithString:UIApplicationOpenSettingsURLString];
+    if ([[UIApplication sharedApplication] canOpenURL:settingsURL]) {
+        [[UIApplication sharedApplication] openURL:settingsURL options:@{} completionHandler:^(BOOL success) {
+            resolve(@(success));
+        }];
+    } else {
+        resolve(@NO);
+    }
+}
+
+
+- (void)requestCameraPermissionWithCompletion:(void (^)(BOOL granted))completion
+{
+    AVAuthorizationStatus status = [AVCaptureDevice authorizationStatusForMediaType:AVMediaTypeVideo];
+    
+    if (status == AVAuthorizationStatusAuthorized) {
+        completion(YES);
+    } else if (status == AVAuthorizationStatusNotDetermined) {
+        [AVCaptureDevice requestAccessForMediaType:AVMediaTypeVideo completionHandler:^(BOOL granted) {
+            dispatch_async(dispatch_get_main_queue(), ^{
+                completion(granted);
+            });
+        }];
+    } else {
+        completion(NO);
+    }
+}
+
+- (void)requestGalleryPermissionWithCompletion:(void (^)(BOOL granted))completion
+{
+    PHAuthorizationStatus status = [PHPhotoLibrary authorizationStatus];
+    
+    BOOL isAuthorized = (status == PHAuthorizationStatusAuthorized);
+    
+    // Check for limited status on iOS 14+
+    if (@available(iOS 14, *)) {
+        isAuthorized = isAuthorized || (status == PHAuthorizationStatusLimited);
+    }
+    
+    if (isAuthorized) {
+        completion(YES);
+    } else if (status == PHAuthorizationStatusNotDetermined) {
+        [PHPhotoLibrary requestAuthorization:^(PHAuthorizationStatus newStatus) {
+            dispatch_async(dispatch_get_main_queue(), ^{
+                BOOL isGranted = (newStatus == PHAuthorizationStatusAuthorized);
+                
+                // Check for limited status on iOS 14+
+                if (@available(iOS 14, *)) {
+                    isGranted = isGranted || (newStatus == PHAuthorizationStatusLimited);
+                }
+                
+                completion(isGranted);
+            });
+        }];
+    } else {
+        completion(NO);
+    }
+}
+
+- (void)presentImagePickerWithSourceType:(UIImagePickerControllerSourceType)sourceType
+{
+    if (![UIImagePickerController isSourceTypeAvailable:sourceType]) {
+        self.reject(@"SOURCE_NOT_AVAILABLE", @"Source type not available", nil);
+        return;
+    }
+    
+    UIImagePickerController *picker = [[UIImagePickerController alloc] init];
+    picker.delegate = self;
+    picker.sourceType = sourceType;
+    picker.mediaTypes = @[@"public.image"];
+    
+    // Configure options
+    if (self.options[@"allowsEditing"]) {
+        picker.allowsEditing = [self.options[@"allowsEditing"] boolValue];
+    }
+    
+    UIViewController *presentingViewController = RCTPresentedViewController();
+    [presentingViewController presentViewController:picker animated:YES completion:nil];
+}
+
+- (void)presentMultiSelectPicker:(NSInteger)maxSelectionLimit
+{
+    if (@available(iOS 14, *)) {
+        PHPickerConfiguration *configuration = [[PHPickerConfiguration alloc] init];
+        
+        // Configure filter based on media type from options
+        NSString *mediaType = self.options[@"mediaType"] ?: @"photo";
+        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];
+        }
+        
+        configuration.selectionLimit = maxSelectionLimit;
+        configuration.preferredAssetRepresentationMode = PHPickerConfigurationAssetRepresentationModeAutomatic;
+        
+        PHPickerViewController *pickerViewController = [[PHPickerViewController alloc] initWithConfiguration:configuration];
+        pickerViewController.delegate = self;
+        
+        UIViewController *presentingViewController = RCTPresentedViewController();
+        [presentingViewController presentViewController:pickerViewController animated:YES completion:nil];
+        
+        NSLog(@"✅ Multi-select PHPickerViewController presented with mediaType: %@, limit: %ld", mediaType, (long)maxSelectionLimit);
+    } else {
+        // Fallback for iOS < 14: use UIImagePickerController (single selection)
+        NSLog(@"❌ iOS < 14 detected, multi-select not available. Using single image picker as fallback");
+        [self presentImagePickerWithSourceType:UIImagePickerControllerSourceTypePhotoLibrary];
+    }
+}
+
+#pragma mark - UIImagePickerControllerDelegate
+
+- (void)imagePickerController:(UIImagePickerController *)picker didFinishPickingMediaWithInfo:(NSDictionary<UIImagePickerControllerInfoKey,id> *)info
+{
+    [picker dismissViewControllerAnimated:YES completion:nil];
+    
+    UIImage *image = info[UIImagePickerControllerEditedImage] ?: info[UIImagePickerControllerOriginalImage];
+    
+    if (!image) {
+        self.reject(@"NO_IMAGE", @"No image selected", nil);
+        return;
+    }
+    
+    // Apply quality and size constraints
+    CGFloat quality = self.options[@"quality"] ? [self.options[@"quality"] floatValue] : 0.8;
+    NSNumber *maxWidth = self.options[@"maxWidth"];
+    NSNumber *maxHeight = self.options[@"maxHeight"];
+    
+    if (maxWidth || maxHeight) {
+        image = [self resizeImage:image maxWidth:maxWidth maxHeight:maxHeight];
+    }
+    
+    NSData *imageData = UIImageJPEGRepresentation(image, quality);
+    
+    // Save to temporary directory
+    NSString *fileName = [NSString stringWithFormat:@"IMG_%@.jpg", [[NSUUID UUID] UUIDString]];
+    NSString *filePath = [NSTemporaryDirectory() stringByAppendingPathComponent:fileName];
+    
+    if ([imageData writeToFile:filePath atomically:YES]) {
+        NSString *fileURI = [NSString stringWithFormat:@"file://%@", filePath];
+        
+        NSDictionary *result = @{
+            @"success": @YES,
+            @"uri": fileURI,
+            @"fileName": fileName,
+            @"fileSize": @(imageData.length),
+            @"width": @(image.size.width),
+            @"height": @(image.size.height),
+            @"type": @"image/jpeg"
+        };
+        
+        self.resolve(result);
+    } else {
+        self.reject(@"SAVE_ERROR", @"Failed to save image", nil);
+    }
+}
+
+- (void)imagePickerControllerDidCancel:(UIImagePickerController *)picker
+{
+    [picker dismissViewControllerAnimated:YES completion:nil];
+    
+    NSDictionary *result = @{
+        @"success": @NO,
+        @"error": @"User cancelled"
+    };
+    
+    self.resolve(result);
+}
+
+- (UIImage *)resizeImage:(UIImage *)image maxWidth:(NSNumber *)maxWidth maxHeight:(NSNumber *)maxHeight
+{
+    CGSize size = image.size;
+    CGFloat targetWidth = maxWidth ? [maxWidth floatValue] : size.width;
+    CGFloat targetHeight = maxHeight ? [maxHeight floatValue] : size.height;
+    
+    CGFloat widthRatio = targetWidth / size.width;
+    CGFloat heightRatio = targetHeight / size.height;
+    CGFloat ratio = MIN(widthRatio, heightRatio);
+    
+    if (ratio >= 1.0) {
+        return image;
+    }
+    
+    CGSize newSize = CGSizeMake(size.width * ratio, size.height * ratio);
+    
+    UIGraphicsBeginImageContextWithOptions(newSize, NO, 0.0);
+    [image drawInRect:CGRectMake(0, 0, newSize.width, newSize.height)];
+    UIImage *resizedImage = UIGraphicsGetImageFromCurrentImageContext();
+    UIGraphicsEndImageContext();
+    
+    return resizedImage;
+}
+
+#pragma mark - PHPhotoLibraryChangeObserver
+
+- (void)photoLibraryDidChange:(PHChange *)changeInstance
+{
+    NSLog(@"📸 Photo library changed - limited selection may have been updated");
+    
+    // Notify React Native that the photo library changed
+    // This will trigger a refresh of the gallery
+    [self sendEventWithName:@"PhotoLibraryChanged" body:@{}];
+}
+
+#pragma mark - PHPickerViewControllerDelegate
+
+- (void)picker:(PHPickerViewController *)picker didFinishPicking:(NSArray<PHPickerResult *> *)results API_AVAILABLE(ios(14))
+{
+    NSLog(@"📸 PHPickerViewController finished with %lu results", (unsigned long)results.count);
+    
+    [picker dismissViewControllerAnimated:YES completion:^{
+        NSLog(@"✅ PHPickerViewController dismissed");
+        
+        // Check if this was a multi-select operation
+        if (self.options[@"isMultiSelect"] && [self.options[@"isMultiSelect"] boolValue]) {
+            if (results.count == 0) {
+                // User cancelled or selected no images
+                NSDictionary *result = @{
+                    @"success": @NO,
+                    @"error": @"User cancelled or no images selected",
+                    @"images": @[]
+                };
+                self.resolve(result);
+                self.resolve = nil;
+                self.reject = nil;
+                return;
+            }
+            
+            NSLog(@"🎯 Processing %lu multi-select results", (unsigned long)results.count);
+            [self processMultiSelectResults:results];
+        } else {
+            // This was a limited library picker interaction
+            NSLog(@"📸 Limited library picker interaction completed - triggering gallery refresh");
+            
+            // Trigger a refresh to show any changes in the photo selection
+            dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(1.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
+                [self sendEventWithName:@"PhotoLibraryChanged" body:@{}];
+            });
+        }
+    }];
+}
+
+
+- (void)processMultiSelectResults:(NSArray<PHPickerResult *> *)results API_AVAILABLE(ios(14))
+{
+    NSMutableArray *processedMedia = [[NSMutableArray alloc] init];
+    dispatch_group_t group = dispatch_group_create();
+    
+    BOOL includeBase64 = [self.options[@"includeBase64"] boolValue];
+    CGFloat quality = [self.options[@"quality"] floatValue];
+    NSNumber *maxWidth = self.options[@"maxWidth"];
+    NSNumber *maxHeight = self.options[@"maxHeight"];
+    
+    NSLog(@"🔄 Starting to process %lu media items with options: includeBase64=%@, quality=%.1f", 
+          (unsigned long)results.count, includeBase64 ? @"YES" : @"NO", quality);
+    
+    for (NSInteger i = 0; i < results.count; i++) {
+        PHPickerResult *result = results[i];
+        
+        dispatch_group_enter(group);
+        
+        // Check what type of media this is
+        if ([result.itemProvider hasItemConformingToTypeIdentifier:@"public.image"]) {
+            // Process as image
+            [result.itemProvider loadObjectOfClass:[UIImage class] completionHandler:^(__kindof id<NSItemProviderReading> _Nullable object, NSError * _Nullable error) {
+                if ([object isKindOfClass:[UIImage class]]) {
+                    UIImage *image = (UIImage *)object;
+                    
+                    // Apply size constraints if specified
+                    if (maxWidth || maxHeight) {
+                        image = [self resizeImage:image maxWidth:maxWidth maxHeight:maxHeight];
+                    }
+                    
+                    // Generate unique filename
+                    NSString *fileName = [NSString stringWithFormat:@"multi_select_img_%ld_%@.jpg", (long)i, [[NSUUID UUID] UUIDString]];
+                    NSString *filePath = [NSTemporaryDirectory() stringByAppendingPathComponent:fileName];
+                    
+                    // Convert to JPEG data
+                    NSData *imageData = UIImageJPEGRepresentation(image, quality);
+                    
+                    if ([imageData writeToFile:filePath atomically:YES]) {
+                        NSString *fileURI = [NSString stringWithFormat:@"file://%@", filePath];
+                        
+                        NSMutableDictionary *imageInfo = [[NSMutableDictionary alloc] init];
+                        imageInfo[@"uri"] = fileURI;
+                        imageInfo[@"fileName"] = fileName;
+                        imageInfo[@"fileSize"] = @(imageData.length);
+                        imageInfo[@"width"] = @(image.size.width);
+                        imageInfo[@"height"] = @(image.size.height);
+                        imageInfo[@"type"] = @"image/jpeg";
+                        imageInfo[@"id"] = [[NSUUID UUID] UUIDString];
+                        
+                        // Add base64 if requested
+                        if (includeBase64) {
+                            NSString *base64String = [imageData base64EncodedStringWithOptions:0];
+                            imageInfo[@"base64"] = [NSString stringWithFormat:@"data:image/jpeg;base64,%@", base64String];
+                        }
+                        
+                        @synchronized (processedMedia) {
+                            [processedMedia addObject:imageInfo];
+                        }
+                        
+                        NSLog(@"✅ Processed image %ld: %@", (long)i, fileName);
+                    } else {
+                        NSLog(@"❌ Failed to save image %ld", (long)i);
+                    }
+                } else {
+                    NSLog(@"❌ Failed to load image %ld: %@", (long)i, error.localizedDescription);
+                }
+                
+                dispatch_group_leave(group);
+            }];
+        } else if ([result.itemProvider hasItemConformingToTypeIdentifier:@"public.movie"]) {
+            // Process as video - but skip base64 conversion for iOS
+            [result.itemProvider loadFileRepresentationForTypeIdentifier:@"public.movie" completionHandler:^(NSURL * _Nullable url, NSError * _Nullable error) {
+                if (url && !error) {
+                    // Generate unique filename
+                    NSString *fileName = [NSString stringWithFormat:@"multi_select_video_%ld_%@.mp4", (long)i, [[NSUUID UUID] UUIDString]];
+                    NSString *filePath = [NSTemporaryDirectory() stringByAppendingPathComponent:fileName];
+                    NSURL *destinationURL = [NSURL fileURLWithPath:filePath];
+                    
+                    NSError *copyError;
+                    if ([[NSFileManager defaultManager] copyItemAtURL:url toURL:destinationURL error:&copyError]) {
+                        NSString *fileURI = [NSString stringWithFormat:@"file://%@", filePath];
+                        
+                        // Get video metadata
+                        AVAsset *asset = [AVAsset assetWithURL:destinationURL];
+                        CMTime duration = asset.duration;
+                        CGSize videoSize = CGSizeZero;
+                        
+                        NSArray<AVAssetTrack *> *videoTracks = [asset tracksWithMediaType:AVMediaTypeVideo];
+                        if (videoTracks.count > 0) {
+                            AVAssetTrack *videoTrack = videoTracks[0];
+                            videoSize = videoTrack.naturalSize;
+                        }
+                        
+                        NSData *videoData = [NSData dataWithContentsOfURL:destinationURL];
+                        
+                        NSMutableDictionary *videoInfo = [[NSMutableDictionary alloc] init];
+                        videoInfo[@"uri"] = fileURI;
+                        videoInfo[@"fileName"] = fileName;
+                        videoInfo[@"fileSize"] = @(videoData.length);
+                        videoInfo[@"width"] = @((int)videoSize.width);
+                        videoInfo[@"height"] = @((int)videoSize.height);
+                        videoInfo[@"type"] = @"video/mp4";
+                        videoInfo[@"id"] = [[NSUUID UUID] UUIDString];
+                        
+                        // For iOS videos, skip base64 conversion entirely
+                        if (includeBase64) {
+                            NSLog(@"iOS video base64 conversion skipped for performance reasons");
+                            videoInfo[@"base64"] = @""; // Empty base64 for iOS videos
+                        }
+                        
+                        @synchronized (processedMedia) {
+                            [processedMedia addObject:videoInfo];
+                        }
+                        
+                        NSLog(@"✅ Processed video %ld: %@ (no base64)", (long)i, fileName);
+                    } else {
+                        NSLog(@"❌ Failed to copy video %ld: %@", (long)i, copyError.localizedDescription);
+                    }
+                } else {
+                    NSLog(@"❌ Failed to load video %ld: %@", (long)i, error.localizedDescription);
+                }
+                
+                dispatch_group_leave(group);
+            }];
+        } else {
+            // Unknown media type
+            NSLog(@"❌ Unknown media type for item %ld", (long)i);
+            dispatch_group_leave(group);
+        }
+    }
+    
+    dispatch_group_notify(group, dispatch_get_main_queue(), ^{
+        // Sort media to maintain order
+        NSArray *sortedMedia = [processedMedia sortedArrayUsingComparator:^NSComparisonResult(NSDictionary *a, NSDictionary *b) {
+            NSString *fileNameA = a[@"fileName"];
+            NSString *fileNameB = b[@"fileName"];
+            return [fileNameA compare:fileNameB];
+        }];
+        
+        NSLog(@"✅ All media processed successfully. Total: %lu", (unsigned long)sortedMedia.count);
+        
+        NSDictionary *result = @{
+            @"success": @YES,
+            @"images": sortedMedia,
+            @"count": @(sortedMedia.count)
+        };
+        
+        if (self.resolve) {
+            self.resolve(result);
+            self.resolve = nil;
+            self.reject = nil;
+        }
+    });
+}
+
+@end