motorinc-gallery-picker-pro 1.0.0

package/android/src/main/java/com/gallerypicker/imagepicker/ImagePickerModule.java

@@ -0,0 +1,1968 @@
+package com.gallerypicker.imagepicker;
+
+import android.Manifest;
+import android.app.Activity;
+import android.content.ContentUris;
+import android.content.Intent;
+import android.content.pm.PackageManager;
+import android.database.Cursor;
+import android.graphics.Bitmap;
+import android.graphics.BitmapFactory;
+import android.net.Uri;
+import android.os.Build;
+import android.os.Environment;
+import android.provider.MediaStore;
+import android.util.Base64;
+import android.util.Log;
+import android.content.ContentResolver;
+import java.io.InputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.util.UUID;
+
+import androidx.core.app.ActivityCompat;
+import androidx.core.content.ContextCompat;
+import androidx.core.content.FileProvider;
+
+import com.facebook.react.bridge.ActivityEventListener;
+import com.facebook.react.bridge.BaseActivityEventListener;
+import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.modules.core.RCTNativeAppEventEmitter;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.WritableArray;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.bridge.WritableNativeArray;
+import com.facebook.react.bridge.WritableNativeMap;  
+import com.facebook.react.bridge.LifecycleEventListener;
+import com.facebook.react.modules.core.DeviceEventManagerModule;
+
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.text.SimpleDateFormat;
+import java.util.Arrays;
+import java.util.Date;
+import java.util.Locale;
+import java.util.UUID;
+
+public class ImagePickerModule extends ReactContextBaseJavaModule {
+    
+    private static final String[] SUPPORTED_EVENTS = {
+        "PhotoLibraryChanged",
+        "onPermissionRationale"
+    };
+    private static final String TAG = "ImagePickerModule";
+    private static final int CAMERA_REQUEST_CODE = 1001;
+    private static final int GALLERY_REQUEST_CODE = 1002;
+    private static final int CAMERA_PERMISSION_REQUEST_CODE = 2001;
+    private static final int STORAGE_PERMISSION_REQUEST_CODE = 2002;
+    
+    // Android 13+ permission constants
+    private static final String READ_MEDIA_VIDEO = "android.permission.READ_MEDIA_VIDEO";
+    private static final String READ_MEDIA_VISUAL_USER_SELECTED = "android.permission.READ_MEDIA_VISUAL_USER_SELECTED";
+
+    private Promise currentPromise;
+    private ReadableMap currentOptions;
+    private File currentPhotoFile;
+    private boolean waitingForCameraPermission = false;
+    private boolean waitingForStoragePermission = false;
+
+    private final ActivityEventListener activityEventListener = new BaseActivityEventListener() {
+        @Override
+        public void onActivityResult(Activity activity, int requestCode, int resultCode, Intent data) {
+            handleActivityResult(requestCode, resultCode, data);
+        }
+    };
+
+    public ImagePickerModule(ReactApplicationContext reactContext) {
+        super(reactContext);
+        reactContext.addActivityEventListener(activityEventListener);
+        setupPermissionListeners();
+    }
+
+    @Override
+    public String getName() {
+        return "ImagePickerModule";
+    }
+
+    @ReactMethod
+    public void openCamera(ReadableMap options, Promise promise) {
+        currentPromise = promise;
+        currentOptions = options;
+
+        if (!hasCameraPermission()) {
+            waitingForCameraPermission = true;
+            requestCameraPermissionInternal();
+            return;
+        }
+
+        if (!hasStoragePermission()) {
+            waitingForStoragePermission = true;
+            requestStoragePermissionInternal();
+            return;
+        }
+
+        launchCamera();
+    }
+
+    @ReactMethod
+    public void openGallery(ReadableMap options, Promise promise) {
+        currentPromise = promise;
+        currentOptions = options;
+
+        if (!hasStoragePermission()) {
+            waitingForStoragePermission = true;
+            requestStoragePermissionInternal();
+            return;
+        }
+
+        launchGallery();
+    }
+
+    @ReactMethod
+    public void requestCameraPermission(Promise promise) {
+        if (hasCameraPermission()) {
+            promise.resolve(true);
+        } else {
+            // Actually request the permission - use a separate promise to avoid conflicts
+            requestCameraPermissionInternal();
+            // For this method, resolve immediately after requesting, not waiting for result
+            promise.resolve(false); // Will be true once permission is granted
+        }
+    }
+
+    @ReactMethod
+    public void requestGalleryPermission(Promise promise) {
+        if (hasStoragePermission()) {
+            promise.resolve(true);
+        } else {
+            // Actually request the permission - use a separate promise to avoid conflicts  
+            requestStoragePermissionInternal();
+            // For this method, resolve immediately after requesting, not waiting for result
+            promise.resolve(false); // Will be true once permission is granted
+        }
+    }
+
+    @ReactMethod
+    public void openMultiSelectGallery(ReadableMap options, Promise promise) {
+        currentPromise = promise;
+        currentOptions = options;
+
+        if (!hasStoragePermission()) {
+            promise.reject("PERMISSION_DENIED", "Storage permission not granted");
+            return;
+        }
+
+        // Launch gallery with multi-select capability
+        launchMultiSelectGallery(options);
+    }
+
+    @ReactMethod
+    public void managePhotoSelection(Promise promise) {
+        // This method allows users to update their selected photos in limited access mode
+        if (Build.VERSION.SDK_INT >= 34 && isLimitedAccessMode()) {
+            Log.d(TAG, "Opening photo selection management for limited access mode");
+            // Re-request permissions to trigger the photo selection picker
+            requestStoragePermissionInternal();
+            promise.resolve(true);
+        } else {
+            Log.d(TAG, "Not in limited access mode or not Android 14+, opening app settings");
+            // For non-limited mode or older Android, open app permission settings
+            try {
+                Intent intent = new Intent(android.provider.Settings.ACTION_APPLICATION_DETAILS_SETTINGS);
+                intent.setData(android.net.Uri.parse("package:" + getReactApplicationContext().getPackageName()));
+                intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+                getReactApplicationContext().startActivity(intent);
+                promise.resolve(true);
+            } catch (Exception e) {
+                Log.e(TAG, "Error opening app settings: " + e.getMessage());
+                promise.reject("SETTINGS_ERROR", "Failed to open app settings");
+            }
+        }
+    }
+
+    @ReactMethod
+    public void getPhotoLibraryPermissionStatus(Promise promise) {
+        if (hasStoragePermission()) {
+            // Check if we're in limited access mode (Android 14+ partial permissions)
+            if (isLimitedAccessMode()) {
+                promise.resolve("limited");
+            } else {
+                promise.resolve("authorized");
+            }
+        } else {
+            // Check if permission was permanently denied
+            Activity activity = getCurrentActivity();
+            if (activity != null) {
+                String permission;
+                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+                    permission = Manifest.permission.READ_MEDIA_IMAGES;
+                } else {
+                    permission = Manifest.permission.READ_EXTERNAL_STORAGE;
+                }
+                
+                boolean shouldShow = ActivityCompat.shouldShowRequestPermissionRationale(activity, permission);
+                if (!shouldShow) {
+                    // Permission was permanently denied
+                    promise.resolve("denied");
+                } else {
+                    // Permission not requested yet
+                    promise.resolve("not_determined");
+                }
+            } else {
+                promise.resolve("not_determined");
+            }
+        }
+    }
+
+    @ReactMethod
+    public void fetchPhotoLibraryAssets(ReadableMap options, Promise promise) {
+        Log.d(TAG, "fetchPhotoLibraryAssets called, checking permission...");
+        
+        int limit = options.hasKey("limit") ? options.getInt("limit") : 20;
+        int offset = options.hasKey("offset") ? options.getInt("offset") : 0;
+        String mediaType = options.hasKey("mediaType") ? options.getString("mediaType") : "photo";
+        
+        // Check specific permissions based on media type
+        if ("video".equals(mediaType)) {
+            if (!hasVideoPermission()) {
+                Log.e(TAG, "Video permission not granted");
+                promise.reject("PERMISSION_DENIED", "Video permission not granted");
+                return;
+            }
+        } else if ("mixed".equals(mediaType)) {
+            if (!hasImagePermission() && !hasVideoPermission()) {
+                Log.e(TAG, "Neither image nor video permission granted");
+                promise.reject("PERMISSION_DENIED", "Media permissions not granted");
+                return;
+            }
+        } else {
+            // Default to images
+            if (!hasImagePermission()) {
+                Log.e(TAG, "Image permission not granted");
+                promise.reject("PERMISSION_DENIED", "Image permission not granted");
+                return;
+            }
+        }
+
+        Log.d(TAG, "Permission granted for " + mediaType + ", proceeding with fetch");
+        
+        // Check if we're in limited access mode (Android 14+ partial permissions)
+        boolean isLimitedMode = isLimitedAccessMode();
+        
+        // In limited mode, the system already restricts access to user-selected images only
+        // We don't need to artificially limit the count as the MediaStore query will only return
+        // the images the user has granted access to via READ_MEDIA_VISUAL_USER_SELECTED
+        final int finalLimit = limit;
+        
+        Log.d(TAG, "Fetching assets with limit: " + finalLimit + ", offset: " + offset + ", mediaType: " + mediaType + ", limited mode: " + isLimitedMode);
+
+        new Thread(() -> {
+            try {
+                WritableArray assets = new WritableNativeArray();
+                
+                if ("mixed".equals(mediaType)) {
+                    // For mixed media, query both images and videos separately and combine
+                    assets = fetchMixedMediaAssets(offset, finalLimit);
+                } else if ("video".equals(mediaType)) {
+                    // Query videos only
+                    assets = fetchVideoAssets(offset, finalLimit);
+                } else {
+                    // Query images only (default)
+                    assets = fetchImageAssets(offset, finalLimit);
+                }
+
+                Log.d(TAG, "Fetched " + assets.size() + " assets");
+
+                // Get total count with separate query
+                // In limited mode, getTotalMediaCount() will already return the correct count
+                // of user-selected media due to the permission restriction
+                int totalCount = getTotalMediaCount(mediaType);
+                boolean hasMore = (offset + assets.size()) < totalCount;
+
+                Log.d(TAG, "Processed " + assets.size() + " assets, total count: " + totalCount + ", has more: " + hasMore);
+
+                WritableMap result = new WritableNativeMap();
+                result.putArray("assets", assets);
+                result.putBoolean("hasMore", hasMore);
+                result.putInt("totalCount", totalCount);
+
+                promise.resolve(result);
+
+            } catch (Exception e) {
+                Log.e(TAG, "Error fetching gallery assets: " + e.getMessage(), e);
+                promise.reject("FETCH_ERROR", "Failed to fetch gallery assets: " + e.getMessage());
+            }
+        }).start();
+    }
+
+    @ReactMethod
+    public void getImageForAsset(String assetId, Integer targetWidth, Integer targetHeight, Promise promise) {
+        new Thread(() -> {
+            try {
+                Log.d(TAG, "getImageForAsset called with assetId: " + assetId);
+                
+                // Check storage permission first
+                if (!hasStoragePermission()) {
+                    promise.reject("PERMISSION_DENIED", "Storage permission not granted");
+                    return;
+                }
+                
+                Uri contentUri;
+                
+                if (assetId.startsWith("content://")) {
+                    // Already a content URI, use it directly
+                    contentUri = Uri.parse(assetId);
+                    Log.d(TAG, "Using provided content URI: " + contentUri);
+                } else {
+                    // Convert numeric ID to content URI
+                    try {
+                        long id = Long.parseLong(assetId);
+                        
+                        // Try to find the asset in both Images and Videos
+                        contentUri = null;
+                        
+                        // First try images
+                        Uri imageUri = ContentUris.withAppendedId(MediaStore.Images.Media.EXTERNAL_CONTENT_URI, id);
+                        if (assetExists(imageUri)) {
+                            contentUri = imageUri;
+                            Log.d(TAG, "Found as image: " + contentUri);
+                        } else {
+                            // Try videos
+                            Uri videoUri = ContentUris.withAppendedId(MediaStore.Video.Media.EXTERNAL_CONTENT_URI, id);
+                            if (assetExists(videoUri)) {
+                                contentUri = videoUri;
+                                Log.d(TAG, "Found as video: " + contentUri);
+                            }
+                        }
+                        
+                        if (contentUri == null) {
+                            // If not found by ID, maybe the assetId is actually a content URI in disguise
+                            if (assetId.contains("content") || assetId.contains("media")) {
+                                Log.w(TAG, "Trying to parse assetId as potential content URI: " + assetId);
+                                try {
+                                    contentUri = Uri.parse("content://media/external/images/media/" + id);
+                                    if (!assetExists(contentUri)) {
+                                        contentUri = Uri.parse("content://media/external/video/media/" + id);
+                                    }
+                                } catch (Exception ex) {
+                                    Log.e(TAG, "Failed to create fallback content URI: " + ex.getMessage());
+                                }
+                            }
+                            
+                            if (contentUri == null) {
+                                promise.reject("ASSET_NOT_FOUND", "Asset not found with ID: " + assetId);
+                                return;
+                            }
+                        }
+                        
+                    } catch (NumberFormatException e) {
+                        promise.reject("INVALID_ASSET_ID", "Invalid asset ID format: " + assetId);
+                        return;
+                    }
+                }
+                
+                // Default dimensions if not specified
+                int width = targetWidth != null ? targetWidth : 300;
+                int height = targetHeight != null ? targetHeight : 300;
+                
+                Log.d(TAG, "Loading image with dimensions: " + width + "x" + height);
+                
+                // Try to load the image
+                Bitmap bitmap = loadAndResizeBitmapSafely(contentUri, width, height);
+                
+                if (bitmap != null) {
+                    // Save to temporary file
+                    File tempFile = createImageFile();
+                    saveBitmapToFile(bitmap, tempFile);
+                    
+                    String fileUri = "file://" + tempFile.getAbsolutePath();
+                    Log.d(TAG, "Image saved to: " + fileUri);
+                    promise.resolve(fileUri);
+                } else {
+                    Log.e(TAG, "Failed to load bitmap for URI: " + contentUri);
+                    promise.reject("IMAGE_LOAD_ERROR", "Failed to load image from content URI: " + contentUri);
+                }
+                
+            } catch (Exception e) {
+                Log.e(TAG, "Error processing asset: " + e.getMessage(), e);
+                promise.reject("ASSET_PROCESSING_ERROR", "Failed to process asset: " + e.getMessage());
+            }
+        }).start();
+    }
+
+    @ReactMethod
+    public void getVideoBase64(String videoUri, Promise promise) {
+        new Thread(() -> {
+            try {
+                Log.d(TAG, "Getting base64 for video URI: " + videoUri);
+                
+                Uri contentUri = Uri.parse(videoUri);
+                ContentResolver resolver = getReactApplicationContext().getContentResolver();
+                
+                // Check file size first to avoid memory issues
+                long fileSize = 0;
+                String[] sizeProjection = {MediaStore.Video.Media.SIZE};
+                try (Cursor cursor = resolver.query(contentUri, sizeProjection, null, null, null)) {
+                    if (cursor != null && cursor.moveToFirst()) {
+                        int sizeColumn = cursor.getColumnIndex(MediaStore.Video.Media.SIZE);
+                        if (sizeColumn >= 0) {
+                            fileSize = cursor.getLong(sizeColumn);
+                        }
+                    }
+                }
+                
+                // Skip base64 for large files to avoid OutOfMemoryError (limit to 10MB)
+                if (fileSize > 10 * 1024 * 1024) { // 10MB
+                    Log.w(TAG, "Video file too large for base64 conversion: " + fileSize + " bytes. Returning empty base64.");
+                    promise.resolve(""); // Return empty string for large files
+                    return;
+                }
+                
+                // Read the video file into memory (only for smaller files)
+                try (InputStream inputStream = resolver.openInputStream(contentUri);
+                     ByteArrayOutputStream outputStream = new ByteArrayOutputStream()) {
+                    
+                    if (inputStream == null) {
+                        promise.reject("VIDEO_NOT_FOUND", "Could not open video stream for URI: " + videoUri);
+                        return;
+                    }
+                    
+                    byte[] buffer = new byte[8192];
+                    int bytesRead;
+                    long totalBytesRead = 0;
+                    
+                    // Add safety check during reading
+                    while ((bytesRead = inputStream.read(buffer)) != -1) {
+                        totalBytesRead += bytesRead;
+                        
+                        // Additional safety check during read
+                        if (totalBytesRead > 10 * 1024 * 1024) {
+                            Log.w(TAG, "Video file exceeded size limit during reading. Returning empty base64.");
+                            promise.resolve("");
+                            return;
+                        }
+                        
+                        outputStream.write(buffer, 0, bytesRead);
+                    }
+                    
+                    byte[] videoBytes = outputStream.toByteArray();
+                    String base64String = "data:video/mp4;base64," + Base64.encodeToString(videoBytes, Base64.NO_WRAP);
+                    
+                    Log.d(TAG, "Video base64 generated successfully. Length: " + base64String.length());
+                    promise.resolve(base64String);
+                    
+                } catch (IOException e) {
+                    Log.e(TAG, "Error reading video file: " + e.getMessage(), e);
+                    promise.reject("VIDEO_READ_ERROR", "Failed to read video file: " + e.getMessage());
+                }
+                
+            } catch (Exception e) {
+                Log.e(TAG, "Error getting video base64: " + e.getMessage(), e);
+                promise.reject("VIDEO_BASE64_ERROR", "Failed to get video base64: " + e.getMessage());
+            }
+        }).start();
+    }
+
+    @ReactMethod
+    public void openPhotoLibraryLimitedPicker(Promise promise) {
+        // Android doesn't have limited photo access like iOS, but we can simulate it
+        try {
+            Activity activity = getCurrentActivity();
+            if (activity != null) {
+                // Set limited access mode
+                android.content.SharedPreferences prefs = getReactApplicationContext()
+                    .getSharedPreferences("ImagePickerPrefs", android.content.Context.MODE_PRIVATE);
+                prefs.edit().putBoolean("limited_access_mode", true).apply();
+                
+                Intent intent = new Intent(Intent.ACTION_PICK, MediaStore.Images.Media.EXTERNAL_CONTENT_URI);
+                intent.setType("image/*");
+                intent.putExtra(Intent.EXTRA_ALLOW_MULTIPLE, true);
+                activity.startActivityForResult(intent, GALLERY_REQUEST_CODE);
+                
+                // Simulate iOS behavior by sending gallery change event after a delay
+                new Thread(() -> {
+                    try {
+                        Thread.sleep(1000); // Wait for potential changes
+                        sendEvent("PhotoLibraryChanged");
+                    } catch (InterruptedException e) {
+                        Thread.currentThread().interrupt();
+                    }
+                }).start();
+                
+                promise.resolve(true);
+            } else {
+                promise.reject("NO_ACTIVITY", "No current activity available");
+            }
+        } catch (Exception e) {
+            promise.reject("PICKER_ERROR", "Failed to open photo picker: " + e.getMessage());
+        }
+    }
+
+    @ReactMethod
+    public void openPhotoLibraryLimitedSettings(Promise promise) {
+        try {
+            Intent intent = new Intent(android.provider.Settings.ACTION_APPLICATION_DETAILS_SETTINGS);
+            intent.setData(Uri.parse("package:" + getReactApplicationContext().getPackageName()));
+            intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+            
+            Activity activity = getCurrentActivity();
+            if (activity != null) {
+                activity.startActivity(intent);
+                promise.resolve(true);
+            } else {
+                promise.resolve(false);
+            }
+        } catch (Exception e) {
+            promise.resolve(false);
+        }
+    }
+
+    @ReactMethod
+    public void setLimitedAccessMode(boolean limited, Promise promise) {
+        try {
+            android.content.SharedPreferences prefs = getReactApplicationContext()
+                .getSharedPreferences("ImagePickerPrefs", android.content.Context.MODE_PRIVATE);
+            prefs.edit().putBoolean("limited_access_mode", limited).apply();
+            
+            Log.d(TAG, "Limited access mode set to: " + limited);
+            promise.resolve(true);
+        } catch (Exception e) {
+            Log.e(TAG, "Error setting limited access mode: " + e.getMessage());
+            promise.reject("PREFERENCE_ERROR", "Failed to set limited access mode");
+        }
+    }
+
+    @ReactMethod
+    public void testSystemVideoPicker(Promise promise) {
+        try {
+            Log.d(TAG, "🎯 Testing system video picker...");
+            
+            Intent intent = new Intent(Intent.ACTION_PICK);
+            intent.setType("video/*");
+            
+            Activity activity = getCurrentActivity();
+            if (activity != null) {
+                activity.startActivityForResult(intent, 9999); // Use unique code
+                promise.resolve("System picker launched - check if videos appear");
+            } else {
+                promise.reject("NO_ACTIVITY", "No activity available");
+            }
+        } catch (Exception e) {
+            promise.reject("PICKER_ERROR", e.getMessage());
+        }
+    }
+
+    @ReactMethod
+    public void simpleVideoTest(Promise promise) {
+        Log.d(TAG, "🎬 SIMPLE VIDEO TEST START");
+        
+        try {
+            WritableMap result = new WritableNativeMap();
+            
+            // Test 1: Check permissions
+            boolean hasVideo = hasVideoPermission();
+            boolean hasStorage = hasStoragePermission();
+            Log.d(TAG, "🎬 hasVideoPermission: " + hasVideo);
+            Log.d(TAG, "🎬 hasStoragePermission: " + hasStorage);
+            result.putBoolean("hasVideoPermission", hasVideo);
+            result.putBoolean("hasStoragePermission", hasStorage);
+            
+            // Test ALL possible video URIs
+            Uri[] testUris = {
+                MediaStore.Video.Media.EXTERNAL_CONTENT_URI,
+                MediaStore.Video.Media.INTERNAL_CONTENT_URI
+            };
+            
+            // Add volume URIs for Android 10+
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+                try {
+                    Uri volumeExternal = MediaStore.Video.Media.getContentUri(MediaStore.VOLUME_EXTERNAL);
+                    Uri volumeInternal = MediaStore.Video.Media.getContentUri(MediaStore.VOLUME_INTERNAL);
+                    testUris = new Uri[]{
+                        MediaStore.Video.Media.EXTERNAL_CONTENT_URI,
+                        MediaStore.Video.Media.INTERNAL_CONTENT_URI,
+                        volumeExternal,
+                        volumeInternal
+                    };
+                } catch (Exception e) {
+                    Log.w(TAG, "Volume URIs failed: " + e.getMessage());
+                }
+            }
+            
+            WritableArray uriResults = new WritableNativeArray();
+            int totalVideos = 0;
+            
+            for (Uri videoUri : testUris) {
+                Log.d(TAG, "🎬 Testing URI: " + videoUri);
+                
+                Cursor cursor = null;
+                try {
+                    cursor = getReactApplicationContext().getContentResolver().query(
+                        videoUri,
+                        new String[]{MediaStore.Video.Media._ID, MediaStore.Video.Media.DISPLAY_NAME},
+                        null,
+                        null,
+                        null
+                    );
+                    
+                    WritableMap uriResult = new WritableNativeMap();
+                    uriResult.putString("uri", videoUri.toString());
+                    
+                    if (cursor == null) {
+                        Log.w(TAG, "🎬 Cursor null for: " + videoUri);
+                        uriResult.putString("status", "null_cursor");
+                        uriResult.putInt("count", 0);
+                    } else {
+                        int count = cursor.getCount();
+                        Log.d(TAG, "🎬 Found " + count + " videos in: " + videoUri);
+                        uriResult.putString("status", "success");
+                        uriResult.putInt("count", count);
+                        totalVideos += count;
+                        
+                        if (count > 0 && cursor.moveToFirst()) {
+                            long firstVideoId = cursor.getLong(0);
+                            String firstName = cursor.getString(1);
+                            uriResult.putString("firstVideoId", String.valueOf(firstVideoId));
+                            uriResult.putString("firstName", firstName != null ? firstName : "null");
+                            Log.d(TAG, "🎬 First video: " + firstName + " (ID: " + firstVideoId + ")");
+                        }
+                    }
+                    
+                    uriResults.pushMap(uriResult);
+                    
+                } catch (Exception e) {
+                    Log.e(TAG, "🎬 Error querying " + videoUri + ": " + e.getMessage());
+                    WritableMap uriResult = new WritableNativeMap();
+                    uriResult.putString("uri", videoUri.toString());
+                    uriResult.putString("status", "error");
+                    uriResult.putString("error", e.getMessage());
+                    uriResult.putInt("count", 0);
+                    uriResults.pushMap(uriResult);
+                } finally {
+                    if (cursor != null) {
+                        cursor.close();
+                    }
+                }
+            }
+            
+            result.putArray("uriTests", uriResults);
+            result.putInt("totalVideosFound", totalVideos);
+            
+            // Test 3: Call our actual fetchVideoAssets method
+            Log.d(TAG, "🎬 Testing fetchVideoAssets(0, 5)...");
+            WritableArray assets = fetchVideoAssets(0, 5);
+            result.putInt("fetchVideoAssetsCount", assets.size());
+            result.putArray("sampleAssets", assets);
+            
+            Log.d(TAG, "🎬 SIMPLE VIDEO TEST COMPLETE - Total videos found: " + totalVideos);
+            promise.resolve(result);
+            
+        } catch (Exception e) {
+            Log.e(TAG, "🎬 Simple video test failed: " + e.getMessage(), e);
+            promise.reject("TEST_ERROR", e.getMessage());
+        }
+    }
+
+    @ReactMethod 
+    public void testVideoQuery(Promise promise) {
+        try {
+            Log.d(TAG, "=== TESTING VIDEO QUERY WITH CORRECTED IMPLEMENTATION ===");
+            
+            WritableMap result = new WritableNativeMap();
+            WritableArray videos = new WritableNativeArray();
+            
+            // Use the same URI logic as the main implementation
+            Uri videoUri = MediaStore.Video.Media.EXTERNAL_CONTENT_URI;
+            
+            Log.d(TAG, "Testing URI: " + videoUri);
+            Log.d(TAG, "Android API level: " + Build.VERSION.SDK_INT);
+            Log.d(TAG, "Video permission granted: " + hasVideoPermission());
+            
+            String[] projection = {
+                MediaStore.Video.Media._ID,
+                MediaStore.Video.Media.DISPLAY_NAME,
+                MediaStore.Video.Media.DATA,
+                MediaStore.Video.Media.SIZE,
+                MediaStore.Video.Media.DURATION,
+                MediaStore.Video.Media.MIME_TYPE,
+                MediaStore.Video.Media.DATE_ADDED
+            };
+            
+            String sortOrder = MediaStore.Video.Media.DATE_ADDED + " DESC";
+            
+            try (Cursor cursor = getReactApplicationContext().getContentResolver().query(
+                    videoUri,
+                    projection,
+                    null,
+                    null,
+                    sortOrder)) {
+                
+                if (cursor != null) {
+                    int count = cursor.getCount();
+                    Log.d(TAG, "Query returned " + count + " videos");
+                    result.putInt("totalVideoCount", count);
+                    
+                    if (count > 0 && cursor.moveToFirst()) {
+                        int sampleCount = 0;
+                        do {
+                            if (sampleCount >= 5) break; // Limit sample to 5 videos
+                            
+                            long id = cursor.getLong(cursor.getColumnIndexOrThrow(MediaStore.Video.Media._ID));
+                            String name = cursor.getString(cursor.getColumnIndexOrThrow(MediaStore.Video.Media.DISPLAY_NAME));
+                            String data = cursor.getString(cursor.getColumnIndexOrThrow(MediaStore.Video.Media.DATA));
+                            long size = cursor.getLong(cursor.getColumnIndexOrThrow(MediaStore.Video.Media.SIZE));
+                            long duration = cursor.getLong(cursor.getColumnIndexOrThrow(MediaStore.Video.Media.DURATION));
+                            String mimeType = cursor.getString(cursor.getColumnIndexOrThrow(MediaStore.Video.Media.MIME_TYPE));
+                            long dateAdded = cursor.getLong(cursor.getColumnIndexOrThrow(MediaStore.Video.Media.DATE_ADDED));
+                            
+                            Uri contentUri = ContentUris.withAppendedId(videoUri, id);
+                            
+                            WritableMap video = new WritableNativeMap();
+                            video.putString("id", String.valueOf(id));
+                            video.putString("name", name != null ? name : "null");
+                            video.putString("path", data != null ? data : "null");
+                            video.putString("contentUri", contentUri.toString());
+                            video.putDouble("size", size);
+                            video.putDouble("duration", duration / 1000.0);
+                            video.putString("mimeType", mimeType != null ? mimeType : "null");
+                            video.putDouble("dateAdded", dateAdded * 1000L);
+                            
+                            videos.pushMap(video);
+                            sampleCount++;
+                            
+                            Log.d(TAG, "Sample video " + sampleCount + ": " + name + " (ID: " + id + ", Duration: " + (duration/1000.0) + "s, URI: " + contentUri + ")");
+                        } while (cursor.moveToNext());
+                    }
+                } else {
+                    Log.w(TAG, "Cursor is null - query failed");
+                    result.putInt("totalVideoCount", 0);
+                    result.putString("error", "Query returned null cursor");
+                }
+            }
+            
+            result.putArray("sampleVideos", videos);
+            result.putString("queryUri", videoUri.toString());
+            result.putInt("androidVersion", Build.VERSION.SDK_INT);
+            result.putBoolean("hasVideoPermission", hasVideoPermission());
+            
+            Log.d(TAG, "=== VIDEO QUERY TEST COMPLETED ===");
+            promise.resolve(result);
+            
+        } catch (Exception e) {
+            Log.e(TAG, "Video test failed: " + e.getMessage(), e);
+            promise.reject("TEST_ERROR", e.getMessage());
+        }
+    }
+
+    @ReactMethod
+    public void debugPermissionsAndMediaStore(Promise promise) {
+        try {
+            WritableMap debugInfo = new WritableNativeMap();
+            
+            // Check permissions
+            debugInfo.putBoolean("hasStoragePermission", hasStoragePermission());
+            debugInfo.putBoolean("hasImagePermission", hasImagePermission());
+            debugInfo.putBoolean("hasVideoPermission", hasVideoPermission());
+            debugInfo.putInt("androidVersion", Build.VERSION.SDK_INT);
+            
+            // Try to query MediaStore for IMAGES
+            try {
+                Cursor cursor = getReactApplicationContext().getContentResolver().query(
+                    MediaStore.Images.Media.EXTERNAL_CONTENT_URI,
+                    new String[]{MediaStore.Images.Media._ID, MediaStore.Images.Media.DISPLAY_NAME},
+                    null,
+                    null,
+                    MediaStore.Images.Media._ID + " DESC"
+                );
+                
+                if (cursor != null) {
+                    debugInfo.putInt("mediaStoreImageCount", cursor.getCount());
+                    WritableArray sampleImages = new WritableNativeArray();
+                    
+                    while (cursor.moveToNext() && sampleImages.size() < 3) {
+                        long id = cursor.getLong(cursor.getColumnIndexOrThrow(MediaStore.Images.Media._ID));
+                        String name = cursor.getString(cursor.getColumnIndexOrThrow(MediaStore.Images.Media.DISPLAY_NAME));
+                        
+                        WritableMap imageInfo = new WritableNativeMap();
+                        imageInfo.putString("id", String.valueOf(id));
+                        imageInfo.putString("name", name != null ? name : "null");
+                        sampleImages.pushMap(imageInfo);
+                    }
+                    
+                    debugInfo.putArray("sampleImages", sampleImages);
+                    cursor.close();
+                } else {
+                    debugInfo.putInt("mediaStoreImageCount", -1);
+                    debugInfo.putString("mediaStoreImageError", "Cursor is null");
+                }
+            } catch (Exception e) {
+                debugInfo.putString("mediaStoreImageError", e.getMessage());
+                debugInfo.putInt("mediaStoreImageCount", -2);
+            }
+            
+            // Try to query MediaStore for VIDEOS - test both internal and external
+            try {
+                // First test: External storage
+                Cursor videoCursor = getReactApplicationContext().getContentResolver().query(
+                    MediaStore.Video.Media.EXTERNAL_CONTENT_URI,
+                    new String[]{MediaStore.Video.Media._ID, MediaStore.Video.Media.DISPLAY_NAME, MediaStore.Video.Media.DURATION},
+                    null,
+                    null,
+                    MediaStore.Video.Media._ID + " DESC"
+                );
+                
+                if (videoCursor != null) {
+                    debugInfo.putInt("mediaStoreVideoCount", videoCursor.getCount());
+                    WritableArray sampleVideos = new WritableNativeArray();
+                    
+                    while (videoCursor.moveToNext() && sampleVideos.size() < 3) {
+                        long id = videoCursor.getLong(videoCursor.getColumnIndexOrThrow(MediaStore.Video.Media._ID));
+                        String name = videoCursor.getString(videoCursor.getColumnIndexOrThrow(MediaStore.Video.Media.DISPLAY_NAME));
+                        long duration = videoCursor.getLong(videoCursor.getColumnIndexOrThrow(MediaStore.Video.Media.DURATION));
+                        
+                        WritableMap videoInfo = new WritableNativeMap();
+                        videoInfo.putString("id", String.valueOf(id));
+                        videoInfo.putString("name", name != null ? name : "null");
+                        videoInfo.putDouble("duration", duration / 1000.0);
+                        sampleVideos.pushMap(videoInfo);
+                    }
+                    
+                    debugInfo.putArray("sampleVideos", sampleVideos);
+                    videoCursor.close();
+                } else {
+                    debugInfo.putInt("mediaStoreVideoCount", -1);
+                    debugInfo.putString("mediaStoreVideoError", "Video cursor is null");
+                }
+            } catch (Exception e) {
+                debugInfo.putString("mediaStoreVideoError", e.getMessage());
+                debugInfo.putInt("mediaStoreVideoCount", -2);
+            }
+            
+            Log.d(TAG, "Debug info: " + debugInfo.toString());
+            promise.resolve(debugInfo);
+            
+        } catch (Exception e) {
+            Log.e(TAG, "Error getting debug info: " + e.getMessage());
+            promise.reject("DEBUG_ERROR", "Failed to get debug info: " + e.getMessage());
+        }
+    }
+
+    private boolean hasCameraPermission() {
+        return ContextCompat.checkSelfPermission(getReactApplicationContext(),
+                Manifest.permission.CAMERA) == PackageManager.PERMISSION_GRANTED;
+    }
+
+    private boolean hasStoragePermission() {
+        boolean hasImagePermission = false;
+        boolean hasVideoPermission = false;
+        String permissions = "";
+
+        if (Build.VERSION.SDK_INT >= 34) {
+            // Android 14+ - check for limited access first, then full access
+            boolean hasLimitedAccess = ContextCompat.checkSelfPermission(getReactApplicationContext(), 
+                    READ_MEDIA_VISUAL_USER_SELECTED) == PackageManager.PERMISSION_GRANTED;
+            boolean hasFullImageAccess = ContextCompat.checkSelfPermission(getReactApplicationContext(), 
+                    Manifest.permission.READ_MEDIA_IMAGES) == PackageManager.PERMISSION_GRANTED;
+            boolean hasFullVideoAccess = ContextCompat.checkSelfPermission(getReactApplicationContext(), 
+                    READ_MEDIA_VIDEO) == PackageManager.PERMISSION_GRANTED;
+            
+            hasImagePermission = hasLimitedAccess || hasFullImageAccess;
+            hasVideoPermission = hasLimitedAccess || hasFullVideoAccess;
+            permissions = "READ_MEDIA_VISUAL_USER_SELECTED=" + hasLimitedAccess + 
+                         ", READ_MEDIA_IMAGES=" + hasFullImageAccess + 
+                         ", READ_MEDIA_VIDEO=" + hasFullVideoAccess;
+        } else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+            // Android 13 uses granular media permissions
+            hasImagePermission = ContextCompat.checkSelfPermission(getReactApplicationContext(), 
+                    Manifest.permission.READ_MEDIA_IMAGES) == PackageManager.PERMISSION_GRANTED;
+            hasVideoPermission = ContextCompat.checkSelfPermission(getReactApplicationContext(), 
+                    READ_MEDIA_VIDEO) == PackageManager.PERMISSION_GRANTED;
+            permissions = "READ_MEDIA_IMAGES=" + hasImagePermission + ", READ_MEDIA_VIDEO=" + hasVideoPermission;
+        } else {
+            // Android 12 and below use legacy storage permission
+            hasImagePermission = ContextCompat.checkSelfPermission(getReactApplicationContext(),
+                    Manifest.permission.READ_EXTERNAL_STORAGE) == PackageManager.PERMISSION_GRANTED;
+            hasVideoPermission = hasImagePermission; // Same permission for both
+            permissions = "READ_EXTERNAL_STORAGE=" + hasImagePermission;
+        }
+
+        // For now, return true if we have either permission (to maintain compatibility)
+        boolean hasPermission = hasImagePermission || hasVideoPermission;
+        Log.d(TAG, "hasStoragePermission: " + hasPermission + " (" + permissions + ", API: " + Build.VERSION.SDK_INT + ")");
+        return hasPermission;
+    }
+
+    private boolean hasImagePermission() {
+        if (Build.VERSION.SDK_INT >= 34) {
+            // Android 14+
+            boolean hasLimitedAccess = ContextCompat.checkSelfPermission(getReactApplicationContext(), 
+                    READ_MEDIA_VISUAL_USER_SELECTED) == PackageManager.PERMISSION_GRANTED;
+            boolean hasFullAccess = ContextCompat.checkSelfPermission(getReactApplicationContext(), 
+                    Manifest.permission.READ_MEDIA_IMAGES) == PackageManager.PERMISSION_GRANTED;
+            return hasLimitedAccess || hasFullAccess;
+        } else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+            // Android 13
+            return ContextCompat.checkSelfPermission(getReactApplicationContext(), 
+                    Manifest.permission.READ_MEDIA_IMAGES) == PackageManager.PERMISSION_GRANTED;
+        } else {
+            // Android 12 and below
+            return ContextCompat.checkSelfPermission(getReactApplicationContext(),
+                    Manifest.permission.READ_EXTERNAL_STORAGE) == PackageManager.PERMISSION_GRANTED;
+        }
+    }
+
+    private boolean hasVideoPermission() {
+        boolean hasPermission = false;
+        String permissionInfo = "";
+        
+        if (Build.VERSION.SDK_INT >= 34) {
+            // Android 14+
+            boolean hasLimitedAccess = ContextCompat.checkSelfPermission(getReactApplicationContext(), 
+                    READ_MEDIA_VISUAL_USER_SELECTED) == PackageManager.PERMISSION_GRANTED;
+            boolean hasFullAccess = ContextCompat.checkSelfPermission(getReactApplicationContext(), 
+                    READ_MEDIA_VIDEO) == PackageManager.PERMISSION_GRANTED;
+            hasPermission = hasLimitedAccess || hasFullAccess;
+            permissionInfo = "Android 14+: LIMITED=" + hasLimitedAccess + ", FULL_VIDEO=" + hasFullAccess;
+        } else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+            // Android 13
+            hasPermission = ContextCompat.checkSelfPermission(getReactApplicationContext(), 
+                    READ_MEDIA_VIDEO) == PackageManager.PERMISSION_GRANTED;
+            permissionInfo = "Android 13: READ_MEDIA_VIDEO=" + hasPermission;
+        } else {
+            // Android 12 and below
+            hasPermission = ContextCompat.checkSelfPermission(getReactApplicationContext(),
+                    Manifest.permission.READ_EXTERNAL_STORAGE) == PackageManager.PERMISSION_GRANTED;
+            permissionInfo = "Android <=12: READ_EXTERNAL_STORAGE=" + hasPermission;
+        }
+        
+        Log.d(TAG, "hasVideoPermission: " + hasPermission + " (" + permissionInfo + ")");
+        return hasPermission;
+    }
+
+    private boolean isLimitedAccessMode() {
+        if (Build.VERSION.SDK_INT >= 34) {
+            boolean hasLimitedAccess = ContextCompat.checkSelfPermission(getReactApplicationContext(), 
+                    READ_MEDIA_VISUAL_USER_SELECTED) == PackageManager.PERMISSION_GRANTED;
+            boolean hasFullAccess = ContextCompat.checkSelfPermission(getReactApplicationContext(), 
+                    Manifest.permission.READ_MEDIA_IMAGES) == PackageManager.PERMISSION_GRANTED;
+            
+            // Limited access mode means we have limited access but not full access
+            return hasLimitedAccess && !hasFullAccess;
+        }
+        return false;
+    }
+
+    private void requestCameraPermissionInternal() {
+        Activity activity = getCurrentActivity();
+        if (activity != null) {
+            // Show rationale if needed
+            if (ActivityCompat.shouldShowRequestPermissionRationale(activity, Manifest.permission.CAMERA)) {
+                showPermissionRationale("Camera", "This app needs access to your camera to take photos.");
+            }
+            
+            ActivityCompat.requestPermissions(activity,
+                    new String[]{Manifest.permission.CAMERA},
+                    CAMERA_PERMISSION_REQUEST_CODE);
+        }
+    }
+
+    private void requestStoragePermissionInternal() {
+        Activity activity = getCurrentActivity();
+        if (activity != null) {
+            String[] permissions;
+            if (Build.VERSION.SDK_INT >= 34) {
+                // Android 14+ - request both full and limited access for images and videos
+                permissions = new String[]{
+                    Manifest.permission.READ_MEDIA_IMAGES,
+                    READ_MEDIA_VIDEO,
+                    READ_MEDIA_VISUAL_USER_SELECTED
+                };
+            } else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+                // Android 13 - request both media images and videos
+                permissions = new String[]{
+                    Manifest.permission.READ_MEDIA_IMAGES,
+                    READ_MEDIA_VIDEO
+                };
+            } else {
+                // Android 12 and below - use legacy permission
+                permissions = new String[]{Manifest.permission.READ_EXTERNAL_STORAGE};
+            }
+
+            Log.d(TAG, "Requesting storage permissions: " + java.util.Arrays.toString(permissions));
+            
+            // Check if we should show rationale for the primary permission
+            String primaryPermission = permissions[0];
+            if (ActivityCompat.shouldShowRequestPermissionRationale(activity, primaryPermission)) {
+                showPermissionRationale("Storage", "This app needs access to your photos and videos to pick media from gallery.");
+            }
+            
+            ActivityCompat.requestPermissions(activity, permissions, STORAGE_PERMISSION_REQUEST_CODE);
+        }
+    }
+
+    private void launchCamera() {
+        try {
+            Intent takePictureIntent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
+            
+            if (takePictureIntent.resolveActivity(getReactApplicationContext().getPackageManager()) != null) {
+                currentPhotoFile = createImageFile();
+                
+                Uri photoURI = FileProvider.getUriForFile(getReactApplicationContext(),
+                        "com.motorinceditor.fileprovider",
+                        currentPhotoFile);
+                
+                takePictureIntent.putExtra(MediaStore.EXTRA_OUTPUT, photoURI);
+                
+                Activity activity = getCurrentActivity();
+                if (activity != null) {
+                    activity.startActivityForResult(takePictureIntent, CAMERA_REQUEST_CODE);
+                }
+            } else {
+                rejectPromise("CAMERA_NOT_AVAILABLE", "Camera not available");
+            }
+        } catch (Exception e) {
+            rejectPromise("CAMERA_ERROR", e.getMessage());
+        }
+    }
+
+    private void launchGallery() {
+        Intent pickPhotoIntent = new Intent(Intent.ACTION_PICK, MediaStore.Images.Media.EXTERNAL_CONTENT_URI);
+        pickPhotoIntent.setType("image/*");
+        
+        Activity activity = getCurrentActivity();
+        if (activity != null) {
+            activity.startActivityForResult(pickPhotoIntent, GALLERY_REQUEST_CODE);
+        }
+    }
+
+    private void launchMultiSelectGallery(ReadableMap options) {
+        String mediaType = options.hasKey("mediaType") ? options.getString("mediaType") : "photo";
+        
+        Intent pickPhotoIntent = new Intent(Intent.ACTION_PICK);
+        
+        if ("video".equals(mediaType)) {
+            pickPhotoIntent.setData(MediaStore.Video.Media.EXTERNAL_CONTENT_URI);
+            pickPhotoIntent.setType("video/*");
+        } else if ("mixed".equals(mediaType)) {
+            pickPhotoIntent.setType("*/*");
+            String[] mimeTypes = {"image/*", "video/*"};
+            pickPhotoIntent.putExtra(Intent.EXTRA_MIME_TYPES, mimeTypes);
+        } else {
+            pickPhotoIntent.setData(MediaStore.Images.Media.EXTERNAL_CONTENT_URI);
+            pickPhotoIntent.setType("image/*");
+        }
+        
+        // Enable multiple selection
+        pickPhotoIntent.putExtra(Intent.EXTRA_ALLOW_MULTIPLE, true);
+        
+        Activity activity = getCurrentActivity();
+        if (activity != null) {
+            activity.startActivityForResult(pickPhotoIntent, GALLERY_REQUEST_CODE);
+        }
+    }
+
+    private File createImageFile() throws IOException {
+        String timeStamp = new SimpleDateFormat("yyyyMMdd_HHmmss", Locale.getDefault()).format(new Date());
+        String imageFileName = "IMG_" + timeStamp + "_";
+        File storageDir = new File(getReactApplicationContext().getCacheDir(), "images");
+        
+        if (!storageDir.exists()) {
+            storageDir.mkdirs();
+        }
+        
+        return File.createTempFile(imageFileName, ".jpg", storageDir);
+    }
+
+    private void handleActivityResult(int requestCode, int resultCode, Intent data) {
+        if (currentPromise == null) return;
+
+        if (resultCode != Activity.RESULT_OK) {
+            WritableMap result = new WritableNativeMap();
+            result.putBoolean("success", false);
+            result.putString("error", "User cancelled");
+            currentPromise.resolve(result);
+            currentPromise = null;
+            return;
+        }
+
+        try {
+            switch (requestCode) {
+                case CAMERA_REQUEST_CODE:
+                    handleCameraResult();
+                    break;
+                case GALLERY_REQUEST_CODE:
+                    handleGalleryResult(data);
+                    break;
+            }
+        } catch (Exception e) {
+            rejectPromise("PROCESSING_ERROR", e.getMessage());
+        }
+    }
+
+    private void handleCameraResult() throws IOException {
+        if (currentPhotoFile != null && currentPhotoFile.exists()) {
+            processImage(currentPhotoFile);
+        } else {
+            rejectPromise("FILE_ERROR", "Photo file not found");
+        }
+    }
+
+    private void handleGalleryResult(Intent data) throws IOException {
+        // Check if this is a multi-select request by looking at current options
+        boolean isMultiSelect = currentOptions != null && currentOptions.hasKey("maxSelectionLimit");
+        
+        if (isMultiSelect && data.getClipData() != null) {
+            // Multiple images selected
+            processMultipleImages(data.getClipData());
+        } else if (data.getData() != null) {
+            // Single image selection
+            Uri selectedImageUri = data.getData();
+            if (isMultiSelect) {
+                // Convert single selection to multi-select format
+                processSingleImageAsMultiple(selectedImageUri);
+            } else {
+                // Process as single image (existing behavior)
+                File tempFile = createImageFile();
+                copyUriToFile(selectedImageUri, tempFile);
+                processImage(tempFile);
+            }
+        } else {
+            rejectPromise("URI_ERROR", "No image URI found");
+        }
+        
+        // Notify that gallery might have changed (similar to iOS)
+        sendEvent("PhotoLibraryChanged");
+    }
+
+    private void copyUriToFile(Uri uri, File file) throws IOException {
+        try (InputStream inputStream = getReactApplicationContext().getContentResolver().openInputStream(uri);
+             FileOutputStream outputStream = new FileOutputStream(file)) {
+            
+            byte[] buffer = new byte[4096];
+            int bytesRead;
+            while ((bytesRead = inputStream.read(buffer)) != -1) {
+                outputStream.write(buffer, 0, bytesRead);
+            }
+        }
+    }
+
+    private void processMultipleImages(android.content.ClipData clipData) {
+        try {
+            int maxSelectionLimit = currentOptions.hasKey("maxSelectionLimit") ? currentOptions.getInt("maxSelectionLimit") : 10;
+            boolean includeBase64 = currentOptions.hasKey("includeBase64") ? currentOptions.getBoolean("includeBase64") : true;
+            double quality = currentOptions.hasKey("quality") ? currentOptions.getDouble("quality") : 0.8;
+            
+            int mediaCount = Math.min(clipData.getItemCount(), maxSelectionLimit);
+            WritableArray mediaArray = new WritableNativeArray();
+            
+            for (int i = 0; i < mediaCount; i++) {
+                Uri mediaUri = clipData.getItemAt(i).getUri();
+                WritableMap mediaData = processMediaUri(mediaUri, i, quality, includeBase64);
+                if (mediaData != null) {
+                    mediaArray.pushMap(mediaData);
+                }
+            }
+            
+            WritableMap result = new WritableNativeMap();
+            result.putBoolean("success", true);
+            result.putArray("images", mediaArray);
+            result.putInt("count", mediaArray.size());
+            
+            currentPromise.resolve(result);
+            currentPromise = null;
+            
+        } catch (Exception e) {
+            rejectPromise("PROCESSING_ERROR", "Error processing multiple media items: " + e.getMessage());
+        }
+    }
+
+    private void processSingleImageAsMultiple(Uri mediaUri) {
+        try {
+            boolean includeBase64 = currentOptions.hasKey("includeBase64") ? currentOptions.getBoolean("includeBase64") : true;
+            double quality = currentOptions.hasKey("quality") ? currentOptions.getDouble("quality") : 0.8;
+            
+            WritableMap mediaData = processMediaUri(mediaUri, 0, quality, includeBase64);
+            if (mediaData != null) {
+                WritableArray mediaArray = new WritableNativeArray();
+                mediaArray.pushMap(mediaData);
+                
+                WritableMap result = new WritableNativeMap();
+                result.putBoolean("success", true);
+                result.putArray("images", mediaArray);
+                result.putInt("count", 1);
+                
+                currentPromise.resolve(result);
+            } else {
+                rejectPromise("PROCESSING_ERROR", "Failed to process selected media");
+            }
+            currentPromise = null;
+            
+        } catch (Exception e) {
+            rejectPromise("PROCESSING_ERROR", "Error processing single image: " + e.getMessage());
+        }
+    }
+
+    private WritableMap processImageUri(Uri imageUri, int index, double quality, boolean includeBase64) {
+        try {
+            File tempFile = createImageFile();
+            copyUriToFile(imageUri, tempFile);
+            
+            Bitmap bitmap = BitmapFactory.decodeFile(tempFile.getAbsolutePath());
+            if (bitmap == null) {
+                Log.e(TAG, "Failed to decode image at index " + index);
+                return null;
+            }
+            
+            // Apply options (resize, quality, etc.)
+            if (currentOptions != null) {
+                if (currentOptions.hasKey("maxWidth") || currentOptions.hasKey("maxHeight")) {
+                    int maxWidth = currentOptions.hasKey("maxWidth") ? 
+                        currentOptions.getInt("maxWidth") : bitmap.getWidth();
+                    int maxHeight = currentOptions.hasKey("maxHeight") ? 
+                        currentOptions.getInt("maxHeight") : bitmap.getHeight();
+                    
+                    bitmap = resizeBitmap(bitmap, maxWidth, maxHeight);
+                }
+            }
+            
+            // Save processed image
+            File processedFile = createImageFile();
+            saveBitmapToFile(bitmap, processedFile);
+            
+            // Create image data object
+            WritableMap imageData = new WritableNativeMap();
+            imageData.putString("uri", "file://" + processedFile.getAbsolutePath());
+            imageData.putString("fileName", processedFile.getName());
+            imageData.putDouble("fileSize", processedFile.length());
+            imageData.putInt("width", bitmap.getWidth());
+            imageData.putInt("height", bitmap.getHeight());
+            imageData.putString("type", "image/jpeg");
+            imageData.putString("id", UUID.randomUUID().toString());
+            
+            // Add base64 if requested
+            if (includeBase64) {
+                try {
+                    java.io.FileInputStream fileInputStream = new java.io.FileInputStream(processedFile);
+                    byte[] imageBytes = new byte[(int) processedFile.length()];
+                    fileInputStream.read(imageBytes);
+                    fileInputStream.close();
+                    
+                    String base64String = android.util.Base64.encodeToString(imageBytes, android.util.Base64.NO_WRAP);
+                    imageData.putString("base64", "data:image/jpeg;base64," + base64String);
+                } catch (Exception e) {
+                    Log.w(TAG, "Failed to generate base64 for image " + index + ": " + e.getMessage());
+                }
+            }
+            
+            return imageData;
+            
+        } catch (Exception e) {
+            Log.e(TAG, "Error processing image at index " + index + ": " + e.getMessage());
+            return null;
+        }
+    }
+
+    private WritableMap processMediaUri(Uri mediaUri, int index, double quality, boolean includeBase64) {
+        try {
+            // Determine if this is a video or image by checking the MIME type
+            ContentResolver resolver = getReactApplicationContext().getContentResolver();
+            String mimeType = resolver.getType(mediaUri);
+            
+            if (mimeType != null && mimeType.startsWith("video/")) {
+                return processVideoUri(mediaUri, index, includeBase64);
+            } else {
+                return processImageUri(mediaUri, index, quality, includeBase64);
+            }
+        } catch (Exception e) {
+            Log.e(TAG, "Error processing media at index " + index + ": " + e.getMessage());
+            return null;
+        }
+    }
+
+    private WritableMap processVideoUri(Uri videoUri, int index, boolean includeBase64) {
+        try {
+            Log.d(TAG, "Processing video URI: " + videoUri);
+            
+            // Get video metadata
+            ContentResolver resolver = getReactApplicationContext().getContentResolver();
+            
+            // Query video metadata
+            String[] projection = {
+                MediaStore.Video.Media._ID,
+                MediaStore.Video.Media.DISPLAY_NAME,
+                MediaStore.Video.Media.SIZE,
+                MediaStore.Video.Media.WIDTH,
+                MediaStore.Video.Media.HEIGHT,
+                MediaStore.Video.Media.DURATION
+            };
+            
+            int width = 0, height = 0, duration = 0;
+            long fileSize = 0;
+            String fileName = "video_" + index + ".mp4";
+            
+            try (Cursor cursor = resolver.query(videoUri, projection, null, null, null)) {
+                if (cursor != null && cursor.moveToFirst()) {
+                    int nameColumn = cursor.getColumnIndex(MediaStore.Video.Media.DISPLAY_NAME);
+                    int sizeColumn = cursor.getColumnIndex(MediaStore.Video.Media.SIZE);
+                    int widthColumn = cursor.getColumnIndex(MediaStore.Video.Media.WIDTH);
+                    int heightColumn = cursor.getColumnIndex(MediaStore.Video.Media.HEIGHT);
+                    int durationColumn = cursor.getColumnIndex(MediaStore.Video.Media.DURATION);
+                    
+                    if (nameColumn >= 0) fileName = cursor.getString(nameColumn);
+                    if (sizeColumn >= 0) fileSize = cursor.getLong(sizeColumn);
+                    if (widthColumn >= 0) width = cursor.getInt(widthColumn);
+                    if (heightColumn >= 0) height = cursor.getInt(heightColumn);
+                    if (durationColumn >= 0) duration = cursor.getInt(durationColumn);
+                }
+            }
+            
+            // Create video data object
+            WritableMap videoData = new WritableNativeMap();
+            videoData.putString("uri", videoUri.toString());
+            videoData.putString("fileName", fileName);
+            videoData.putDouble("fileSize", fileSize);
+            videoData.putInt("width", width);
+            videoData.putInt("height", height);
+            videoData.putString("type", "video/mp4");
+            videoData.putString("id", UUID.randomUUID().toString());
+            
+            // Add base64 if requested
+            if (includeBase64) {
+                try {
+                    String base64 = getVideoBase64Sync(videoUri.toString());
+                    videoData.putString("base64", base64);
+                } catch (Exception e) {
+                    Log.w(TAG, "Failed to get base64 for video: " + e.getMessage());
+                    videoData.putString("base64", ""); // Fallback to empty string
+                }
+            }
+            
+            Log.d(TAG, "Successfully processed video: " + fileName);
+            return videoData;
+            
+        } catch (Exception e) {
+            Log.e(TAG, "Error processing video at index " + index + ": " + e.getMessage(), e);
+            return null;
+        }
+    }
+
+    private String getVideoBase64Sync(String videoUri) throws Exception {
+        Uri contentUri = Uri.parse(videoUri);
+        ContentResolver resolver = getReactApplicationContext().getContentResolver();
+        
+        // Check file size first to avoid memory issues
+        long fileSize = 0;
+        String[] sizeProjection = {MediaStore.Video.Media.SIZE};
+        try (Cursor cursor = resolver.query(contentUri, sizeProjection, null, null, null)) {
+            if (cursor != null && cursor.moveToFirst()) {
+                int sizeColumn = cursor.getColumnIndex(MediaStore.Video.Media.SIZE);
+                if (sizeColumn >= 0) {
+                    fileSize = cursor.getLong(sizeColumn);
+                }
+            }
+        }
+        
+        // Skip base64 for large files to avoid OutOfMemoryError (limit to 10MB)
+        if (fileSize > 10 * 1024 * 1024) { // 10MB
+            Log.w(TAG, "Video file too large for base64 conversion: " + fileSize + " bytes. Skipping base64.");
+            return ""; // Return empty string for large files
+        }
+        
+        // Read the video file into memory (only for smaller files)
+        try (InputStream inputStream = resolver.openInputStream(contentUri);
+             ByteArrayOutputStream outputStream = new ByteArrayOutputStream()) {
+            
+            if (inputStream == null) {
+                throw new Exception("Could not open video stream for URI: " + videoUri);
+            }
+            
+            byte[] buffer = new byte[8192];
+            int bytesRead;
+            long totalBytesRead = 0;
+            
+            // Add safety check during reading
+            while ((bytesRead = inputStream.read(buffer)) != -1) {
+                totalBytesRead += bytesRead;
+                
+                // Additional safety check during read
+                if (totalBytesRead > 10 * 1024 * 1024) {
+                    Log.w(TAG, "Video file exceeded size limit during reading. Stopping base64 conversion.");
+                    return "";
+                }
+                
+                outputStream.write(buffer, 0, bytesRead);
+            }
+            
+            byte[] videoBytes = outputStream.toByteArray();
+            return "data:video/mp4;base64," + Base64.encodeToString(videoBytes, Base64.NO_WRAP);
+        }
+    }
+
+    private void processImage(File imageFile) throws IOException {
+        Bitmap bitmap = BitmapFactory.decodeFile(imageFile.getAbsolutePath());
+        
+        if (bitmap == null) {
+            rejectPromise("DECODE_ERROR", "Failed to decode image");
+            return;
+        }
+
+        // Apply options
+        if (currentOptions != null) {
+            if (currentOptions.hasKey("maxWidth") || currentOptions.hasKey("maxHeight")) {
+                int maxWidth = currentOptions.hasKey("maxWidth") ? 
+                    currentOptions.getInt("maxWidth") : bitmap.getWidth();
+                int maxHeight = currentOptions.hasKey("maxHeight") ? 
+                    currentOptions.getInt("maxHeight") : bitmap.getHeight();
+                
+                bitmap = resizeBitmap(bitmap, maxWidth, maxHeight);
+            }
+        }
+
+        // Save processed image
+        File processedFile = createImageFile();
+        saveBitmapToFile(bitmap, processedFile);
+
+        // Create result
+        WritableMap result = new WritableNativeMap();
+        result.putBoolean("success", true);
+        result.putString("uri", "file://" + processedFile.getAbsolutePath());
+        result.putString("fileName", processedFile.getName());
+        result.putDouble("fileSize", processedFile.length());
+        result.putInt("width", bitmap.getWidth());
+        result.putInt("height", bitmap.getHeight());
+        result.putString("type", "image/jpeg");
+
+        currentPromise.resolve(result);
+        currentPromise = null;
+    }
+
+    private Bitmap resizeBitmap(Bitmap bitmap, int maxWidth, int maxHeight) {
+        int width = bitmap.getWidth();
+        int height = bitmap.getHeight();
+
+        float widthRatio = (float) maxWidth / width;
+        float heightRatio = (float) maxHeight / height;
+        float ratio = Math.min(widthRatio, heightRatio);
+
+        if (ratio >= 1.0f) {
+            return bitmap;
+        }
+
+        int newWidth = Math.round(width * ratio);
+        int newHeight = Math.round(height * ratio);
+
+        return Bitmap.createScaledBitmap(bitmap, newWidth, newHeight, true);
+    }
+
+    private void saveBitmapToFile(Bitmap bitmap, File file) throws IOException {
+        float quality = 80f;
+        if (currentOptions != null && currentOptions.hasKey("quality")) {
+            quality = (float) (currentOptions.getDouble("quality") * 100);
+        }
+
+        try (FileOutputStream outputStream = new FileOutputStream(file)) {
+            bitmap.compress(Bitmap.CompressFormat.JPEG, Math.round(quality), outputStream);
+        }
+    }
+
+    private void rejectPromise(String code, String message) {
+        if (currentPromise != null) {
+            currentPromise.reject(code, message);
+            currentPromise = null;
+        }
+    }
+
+    private void setupPermissionListeners() {
+        ReactApplicationContext context = getReactApplicationContext();
+        if (context != null) {
+            context.addLifecycleEventListener(new LifecycleEventListener() {
+                @Override
+                public void onHostResume() {
+                    // Register event listeners when app resumes
+                    Log.d(TAG, "App resumed - checking if permission status changed");
+                    
+                    // Emit event to React Native to refresh permission status and gallery
+                    sendEvent("onAppResume");
+                }
+
+                @Override
+                public void onHostPause() {
+                    // Cleanup if needed - clear any pending operations
+                    Log.d(TAG, "App paused during permission flow");
+                }
+
+                @Override
+                public void onHostDestroy() {
+                    // Cleanup if needed
+                    Log.d(TAG, "App destroyed during permission flow");
+                    // Clear any pending promises to prevent crashes
+                    if (currentPromise != null) {
+                        currentPromise = null;
+                    }
+                    waitingForCameraPermission = false;
+                    waitingForStoragePermission = false;
+                }
+            });
+        }
+    }
+
+    @ReactMethod
+    public void onCameraPermissionResult(boolean granted) {
+        try {
+            if (waitingForCameraPermission) {
+                waitingForCameraPermission = false;
+                if (granted) {
+                    // Check if we also need storage permission for camera
+                    if (!hasStoragePermission()) {
+                        waitingForStoragePermission = true;
+                        requestStoragePermissionInternal();
+                        return;
+                    }
+                    launchCamera();
+                } else {
+                    rejectPromise("CAMERA_PERMISSION_DENIED", "Camera permission was denied");
+                }
+            }
+        } catch (Exception e) {
+            Log.e(TAG, "Error handling camera permission result: " + e.getMessage());
+            rejectPromise("PERMISSION_ERROR", "Error handling camera permission result");
+        }
+    }
+
+    @ReactMethod
+    public void onStoragePermissionResult(boolean granted) {
+        try {
+            Log.d(TAG, "Storage permission result: " + granted + ", waitingForStoragePermission: " + waitingForStoragePermission);
+            
+            if (waitingForStoragePermission) {
+                waitingForStoragePermission = false;
+                if (granted) {
+                    if (waitingForCameraPermission) {
+                        // This was for camera, now launch camera
+                        launchCamera();
+                    } else {
+                        // This was for gallery or manage photo selection - just resolve with success
+                        // The React side will handle refreshing the gallery
+                        Log.d(TAG, "Storage permission granted for gallery/manage - no action needed");
+                    }
+                } else {
+                    rejectPromise("STORAGE_PERMISSION_DENIED", "Storage permission was denied");
+                }
+            }
+        } catch (Exception e) {
+            Log.e(TAG, "Error handling storage permission result: " + e.getMessage());
+            rejectPromise("PERMISSION_ERROR", "Error handling storage permission result");
+        }
+    }
+    
+    private void sendEvent(String eventName, WritableMap params) {
+        ReactApplicationContext context = getReactApplicationContext();
+        if (context != null && context.hasActiveCatalystInstance()) {
+            context.getJSModule(RCTNativeAppEventEmitter.class)
+                .emit(eventName, params);
+        }
+    }
+    
+    private void sendEvent(String eventName) {
+        sendEvent(eventName, null);
+    }
+
+    private Bitmap loadAndResizeBitmapSafely(Uri contentUri, int targetWidth, int targetHeight) {
+        try {
+            return loadAndResizeBitmap(contentUri, targetWidth, targetHeight);
+        } catch (Exception e) {
+            Log.e(TAG, "Error loading bitmap from URI: " + contentUri, e);
+            return null;
+        }
+    }
+    
+    private Bitmap loadAndResizeBitmap(Uri contentUri, int targetWidth, int targetHeight) throws IOException {
+        InputStream inputStream = null;
+        try {
+            inputStream = getReactApplicationContext().getContentResolver().openInputStream(contentUri);
+            if (inputStream == null) {
+                Log.e(TAG, "Failed to open input stream for URI: " + contentUri);
+                return null;
+            }
+            
+            // First, get image dimensions without loading the full image
+            BitmapFactory.Options options = new BitmapFactory.Options();
+            options.inJustDecodeBounds = true;
+            BitmapFactory.decodeStream(inputStream, null, options);
+            inputStream.close();
+            
+            if (options.outWidth <= 0 || options.outHeight <= 0) {
+                Log.e(TAG, "Invalid image dimensions: " + options.outWidth + "x" + options.outHeight);
+                return null;
+            }
+            
+            // Calculate sample size for efficient loading
+            int sampleSize = calculateSampleSize(options.outWidth, options.outHeight, targetWidth, targetHeight);
+            Log.d(TAG, "Original size: " + options.outWidth + "x" + options.outHeight + ", sample size: " + sampleSize);
+            
+            // Load the image with sample size
+            inputStream = getReactApplicationContext().getContentResolver().openInputStream(contentUri);
+            if (inputStream == null) {
+                Log.e(TAG, "Failed to reopen input stream for URI: " + contentUri);
+                return null;
+            }
+            
+            options.inJustDecodeBounds = false;
+            options.inSampleSize = sampleSize;
+            options.inPreferredConfig = Bitmap.Config.RGB_565; // Use less memory
+            
+            Bitmap bitmap = BitmapFactory.decodeStream(inputStream, null, options);
+            inputStream.close();
+            
+            if (bitmap == null) {
+                Log.e(TAG, "BitmapFactory.decodeStream returned null for URI: " + contentUri);
+                return null;
+            }
+            
+            Log.d(TAG, "Loaded bitmap size: " + bitmap.getWidth() + "x" + bitmap.getHeight());
+            
+            // Further resize if needed to match exact target dimensions
+            return resizeBitmap(bitmap, targetWidth, targetHeight);
+            
+        } finally {
+            if (inputStream != null) {
+                try {
+                    inputStream.close();
+                } catch (IOException e) {
+                    Log.e(TAG, "Error closing input stream", e);
+                }
+            }
+        }
+    }
+    
+    private int calculateSampleSize(int width, int height, int targetWidth, int targetHeight) {
+        int sampleSize = 1;
+        
+        if (height > targetHeight || width > targetWidth) {
+            final int halfHeight = height / 2;
+            final int halfWidth = width / 2;
+            
+            while ((halfHeight / sampleSize) >= targetHeight && (halfWidth / sampleSize) >= targetWidth) {
+                sampleSize *= 2;
+            }
+        }
+        
+        return sampleSize;
+    }
+
+    private void showPermissionRationale(String permissionType, String message) {
+        // For now, just log the rationale. In a production app, you might want to show a dialog
+        Log.i(TAG, permissionType + " Permission Rationale: " + message);
+        
+        // You could emit an event to React Native to show a custom dialog
+        WritableMap params = new WritableNativeMap();
+        params.putString("type", permissionType.toLowerCase());
+        params.putString("message", message);
+        
+        ReactApplicationContext context = getReactApplicationContext();
+        if (context != null && context.hasActiveCatalystInstance()) {
+            context.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
+                .emit("onPermissionRationale", params);
+        }
+    }
+
+    private boolean isValidImageFile(Uri uri) {
+        try {
+            InputStream inputStream = getReactApplicationContext().getContentResolver().openInputStream(uri);
+            if (inputStream != null) {
+                inputStream.close();
+                return true;
+            }
+        } catch (Exception e) {
+            Log.w(TAG, "Invalid image file: " + uri + " - " + e.getMessage());
+        }
+        return false;
+    }
+
+    private WritableArray fetchImageAssets(int offset, int limit) {
+        WritableArray assets = new WritableNativeArray();
+        Log.d(TAG, "fetchImageAssets called with offset=" + offset + ", limit=" + limit);
+        
+        String[] projection = {
+            MediaStore.Images.Media._ID,
+            MediaStore.Images.Media.DISPLAY_NAME,
+            MediaStore.Images.Media.DATE_ADDED,
+            MediaStore.Images.Media.WIDTH,
+            MediaStore.Images.Media.HEIGHT,
+            MediaStore.Images.Media.SIZE,
+            MediaStore.Images.Media.MIME_TYPE
+        };
+        
+        // Use standard SQL LIMIT OFFSET syntax - some Android versions might not support this in MediaStore
+        String sortOrder = MediaStore.Images.Media.DATE_ADDED + " DESC";
+        Log.d(TAG, "Using sortOrder: " + sortOrder + " with manual offset/limit");
+        
+        try (Cursor cursor = getReactApplicationContext().getContentResolver().query(
+                MediaStore.Images.Media.EXTERNAL_CONTENT_URI,
+                projection,
+                null,
+                null,
+                sortOrder)) {
+            
+            Log.d(TAG, "Images query result: " + (cursor != null ? cursor.getCount() + " items" : "null"));
+            
+            if (cursor != null && cursor.getCount() > 0) {
+                // Manual offset/limit handling
+                int currentIndex = 0;
+                int addedCount = 0;
+                
+                while (cursor.moveToNext() && addedCount < limit) {
+                    // Skip items before offset
+                    if (currentIndex < offset) {
+                        currentIndex++;
+                        continue;
+                    }
+                    
+                    try {
+                        long id = cursor.getLong(cursor.getColumnIndexOrThrow(MediaStore.Images.Media._ID));
+                        String displayName = cursor.getString(cursor.getColumnIndexOrThrow(MediaStore.Images.Media.DISPLAY_NAME));
+                        long dateAdded = cursor.getLong(cursor.getColumnIndexOrThrow(MediaStore.Images.Media.DATE_ADDED));
+                        int width = cursor.getInt(cursor.getColumnIndexOrThrow(MediaStore.Images.Media.WIDTH));
+                        int height = cursor.getInt(cursor.getColumnIndexOrThrow(MediaStore.Images.Media.HEIGHT));
+                        
+                        Uri contentUri = ContentUris.withAppendedId(MediaStore.Images.Media.EXTERNAL_CONTENT_URI, id);
+                        
+                        WritableMap asset = new WritableNativeMap();
+                        asset.putString("uri", contentUri.toString()); // Use actual content URI
+                        asset.putString("id", String.valueOf(id));
+                        asset.putString("filename", displayName != null ? displayName : "Unknown");
+                        asset.putInt("width", width > 0 ? width : 0);
+                        asset.putInt("height", height > 0 ? height : 0);
+                        asset.putDouble("creationDate", dateAdded * 1000L);
+                        asset.putString("mediaType", "image");
+                        
+                        assets.pushMap(asset);
+                        addedCount++;
+                        Log.d(TAG, "Added image: " + displayName + " (ID: " + id + ", index: " + currentIndex + ")");
+                        
+                    } catch (Exception e) {
+                        Log.w(TAG, "Error processing image row: " + e.getMessage());
+                    }
+                    
+                    currentIndex++;
+                }
+                
+                Log.d(TAG, "Final result: added " + addedCount + " images starting from offset " + offset);
+            } else {
+                Log.w(TAG, "No images found in MediaStore or cursor is null");
+            }
+        } catch (Exception e) {
+            Log.e(TAG, "Error fetching images: " + e.getMessage(), e);
+        }
+        
+        return assets;
+    }
+    
+    private WritableArray fetchVideoAssets(int offset, int limit) {
+        WritableArray assets = new WritableNativeArray();
+        Log.d(TAG, "🎬 fetchVideoAssets called with offset=" + offset + ", limit=" + limit);
+        
+        String[] projection = {
+            MediaStore.Video.Media._ID,
+            MediaStore.Video.Media.DISPLAY_NAME,
+            MediaStore.Video.Media.DATE_ADDED,
+            MediaStore.Video.Media.WIDTH,
+            MediaStore.Video.Media.HEIGHT,
+            MediaStore.Video.Media.SIZE,
+            MediaStore.Video.Media.MIME_TYPE,
+            MediaStore.Video.Media.DURATION
+        };
+        
+        String sortOrder = MediaStore.Video.Media.DATE_ADDED + " DESC";
+        Log.d(TAG, "🎬 Using simple sortOrder: " + sortOrder);
+        
+        try (Cursor cursor = getReactApplicationContext().getContentResolver().query(
+                MediaStore.Video.Media.EXTERNAL_CONTENT_URI,
+                projection,
+                null,
+                null,
+                sortOrder)) {
+            
+            Log.d(TAG, "🎬 Videos query result: " + (cursor != null ? cursor.getCount() + " items" : "null"));
+            
+            if (cursor != null && cursor.getCount() > 0) {
+                int addedCount = 0;
+                int currentIndex = 0;
+                
+                // Skip to offset position
+                while (currentIndex < offset && cursor.moveToNext()) {
+                    currentIndex++;
+                }
+                
+                // Now process items up to limit
+                while (addedCount < limit && cursor.moveToNext()) {
+                    try {
+                        long id = cursor.getLong(cursor.getColumnIndexOrThrow(MediaStore.Video.Media._ID));
+                        String displayName = cursor.getString(cursor.getColumnIndexOrThrow(MediaStore.Video.Media.DISPLAY_NAME));
+                        long dateAdded = cursor.getLong(cursor.getColumnIndexOrThrow(MediaStore.Video.Media.DATE_ADDED));
+                        int width = cursor.getInt(cursor.getColumnIndexOrThrow(MediaStore.Video.Media.WIDTH));
+                        int height = cursor.getInt(cursor.getColumnIndexOrThrow(MediaStore.Video.Media.HEIGHT));
+                        long duration = cursor.getLong(cursor.getColumnIndexOrThrow(MediaStore.Video.Media.DURATION));
+                        
+                        Uri contentUri = ContentUris.withAppendedId(MediaStore.Video.Media.EXTERNAL_CONTENT_URI, id);
+                        
+                        WritableMap asset = new WritableNativeMap();
+                        asset.putString("uri", contentUri.toString());
+                        asset.putString("id", String.valueOf(id));
+                        asset.putString("filename", displayName != null ? displayName : "Unknown");
+                        asset.putInt("width", width > 0 ? width : 0);
+                        asset.putInt("height", height > 0 ? height : 0);
+                        asset.putDouble("creationDate", dateAdded * 1000L);
+                        asset.putString("mediaType", "video");
+                        asset.putDouble("duration", duration > 0 ? duration / 1000.0 : 0.0);
+                        
+                        assets.pushMap(asset);
+                        addedCount++;
+                        Log.d(TAG, "🎬 Added video: " + displayName + " (ID: " + id + ")");
+                        
+                    } catch (Exception e) {
+                        Log.w(TAG, "🎬 Error processing video row: " + e.getMessage());
+                    }
+                }
+                
+                Log.d(TAG, "🎬 Successfully added " + addedCount + " videos with SQL LIMIT/OFFSET");
+            } else {
+                Log.w(TAG, "🎬 No videos found in MediaStore or cursor is null");
+            }
+        } catch (Exception e) {
+            Log.e(TAG, "🎬 Error fetching videos: " + e.getMessage(), e);
+        }
+        
+        Log.d(TAG, "🎬 Final result: " + assets.size() + " videos");
+        return assets;
+    }
+    
+    private WritableArray fetchMixedMediaAssets(int offset, int limit) {
+        WritableArray allAssets = new WritableNativeArray();
+        Log.d(TAG, "fetchMixedMediaAssets called with offset=" + offset + ", limit=" + limit);
+        
+        // For mixed media, we need to query both image and video stores and combine results
+        // This is more complex but more efficient than fetching everything then sorting
+        
+        java.util.List<WritableMap> combinedList = new java.util.ArrayList<>();
+        
+        // For mixed media, fetch ALL images and videos, then sort and apply pagination
+        // This ensures proper chronological mixing across all media
+        
+        // Fetch ALL images
+        WritableArray imageAssets = fetchImageAssets(0, Integer.MAX_VALUE);
+        for (int i = 0; i < imageAssets.size(); i++) {
+            ReadableMap readableMap = imageAssets.getMap(i);
+            WritableMap writableMap = new WritableNativeMap();
+            writableMap.merge(readableMap);
+            combinedList.add(writableMap);
+        }
+        
+        // Fetch ALL videos
+        WritableArray videoAssets = fetchVideoAssets(0, Integer.MAX_VALUE);
+        for (int i = 0; i < videoAssets.size(); i++) {
+            ReadableMap readableMap = videoAssets.getMap(i);
+            WritableMap writableMap = new WritableNativeMap();
+            writableMap.merge(readableMap);
+            combinedList.add(writableMap);
+        }
+        
+        // Sort by creation date (descending)
+        combinedList.sort((a, b) -> {
+            try {
+                double dateA = a.getDouble("creationDate");
+                double dateB = b.getDouble("creationDate");
+                return Double.compare(dateB, dateA);
+            } catch (Exception e) {
+                Log.w(TAG, "Error comparing dates for sorting: " + e.getMessage());
+                return 0;
+            }
+        });
+        
+        // Apply offset and limit
+        int startIndex = Math.min(offset, combinedList.size());
+        int endIndex = Math.min(offset + limit, combinedList.size());
+        
+        for (int i = startIndex; i < endIndex; i++) {
+            allAssets.pushMap(combinedList.get(i));
+        }
+        
+        Log.d(TAG, "Mixed media result: " + imageAssets.size() + " images + " + videoAssets.size() + 
+              " videos = " + combinedList.size() + " total, returning " + allAssets.size() + " items (offset: " + offset + ")");
+        
+        return allAssets;
+    }
+
+    private int getTotalMediaCount(String mediaType) {
+        try {
+            int totalCount = 0;
+            
+            if ("mixed".equals(mediaType)) {
+                // Count both images and videos
+                totalCount += getTotalImagesCount();
+                totalCount += getTotalVideosCount();
+            } else if ("video".equals(mediaType)) {
+                totalCount = getTotalVideosCount();
+            } else {
+                // Default to images
+                totalCount = getTotalImagesCount();
+            }
+            
+            Log.d(TAG, "Total " + mediaType + " count: " + totalCount);
+            return totalCount;
+        } catch (Exception e) {
+            Log.e(TAG, "Error getting total " + mediaType + " count: " + e.getMessage(), e);
+        }
+        return 0;
+    }
+    
+    private int getTotalImagesCount() {
+        try (Cursor cursor = getReactApplicationContext().getContentResolver().query(
+                MediaStore.Images.Media.EXTERNAL_CONTENT_URI,
+                new String[]{MediaStore.Images.Media._ID},
+                null,
+                null,
+                null)) {
+            
+            return cursor != null ? cursor.getCount() : 0;
+        } catch (Exception e) {
+            Log.e(TAG, "Error getting images count: " + e.getMessage());
+            return 0;
+        }
+    }
+    
+    private int getTotalVideosCount() {
+        try (Cursor cursor = getReactApplicationContext().getContentResolver().query(
+                MediaStore.Video.Media.EXTERNAL_CONTENT_URI,
+                new String[]{MediaStore.Video.Media._ID},
+                null,
+                null,
+                null)) {
+            
+            return cursor != null ? cursor.getCount() : 0;
+        } catch (Exception e) {
+            Log.e(TAG, "Error getting videos count: " + e.getMessage());
+            return 0;
+        }
+    }
+    
+    private boolean assetExists(Uri uri) {
+        try (Cursor cursor = getReactApplicationContext().getContentResolver().query(
+                uri,
+                new String[]{"1"},
+                null,
+                null,
+                null)) {
+            
+            return cursor != null && cursor.getCount() > 0;
+        } catch (Exception e) {
+            Log.d(TAG, "Asset does not exist: " + uri);
+            return false;
+        }
+    }
+}