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

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

@@ -6,7 +6,6 @@ import android.content.ActivityNotFoundException;
 import android.content.Context;
 import android.content.DialogInterface;
 import android.content.Intent;
-import android.content.pm.ResolveInfo;
 import android.graphics.Bitmap;
 import android.graphics.BitmapFactory;
 import android.net.Uri;
@@ -14,7 +13,10 @@ import android.os.Build;
 import android.os.Handler;
 import android.provider.MediaStore;
 import android.provider.Settings;
+import androidx.activity.result.PickVisualMediaRequest;
+import androidx.activity.result.contract.ActivityResultContracts;
 import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
 import androidx.annotation.StyleRes;
 import androidx.core.app.ActivityCompat;
 import androidx.appcompat.app.AlertDialog;
@@ -47,7 +49,6 @@ import java.io.IOException;
 import java.io.InputStream;
 import java.io.UnsupportedEncodingException;
 import java.lang.ref.WeakReference;
-import java.util.List;
 
 import com.facebook.react.modules.core.PermissionListener;
 import com.facebook.react.modules.core.PermissionAwareActivity;
@@ -69,6 +70,8 @@ public class ImagePickerModule extends ReactContextBaseJavaModule
   public static final int REQUEST_LAUNCH_VIDEO_LIBRARY    = 13003;
   public static final int REQUEST_LAUNCH_VIDEO_CAPTURE    = 13004;
   public static final int REQUEST_PERMISSIONS_FOR_CAMERA  = 14001;
+  // The system Photo Picker needs no storage permission. We only (opportunistically) ask for
+  // ACCESS_MEDIA_LOCATION so that EXIF GPS can be read when the provider is willing to hand it back.
   public static final int REQUEST_PERMISSIONS_FOR_LIBRARY = 14002;
 
   private final ReactApplicationContext reactContext;
@@ -91,6 +94,7 @@ public class ImagePickerModule extends ReactContextBaseJavaModule
   private int videoDurationLimit = 0;
 
   private ResponseHelper responseHelper = new ResponseHelper();
+  private boolean mediaLocationRequested = false;
   private PermissionListener listener = new PermissionListener()
   {
     public boolean onRequestPermissionsResult(final int requestCode,
@@ -109,24 +113,26 @@ public class ImagePickerModule extends ReactContextBaseJavaModule
         return false;
       }
 
-      if (!permissionsGranted)
-      {
-        responseHelper.invokeError(permissionRequestCallback, "Permissions weren't granted");
-        return false;
-      }
-
       switch (requestCode)
       {
         case REQUEST_PERMISSIONS_FOR_CAMERA:
+          if (!permissionsGranted)
+          {
+            responseHelper.invokeError(permissionRequestCallback, "Permissions weren't granted");
+            callback = null;
+            return false;
+          }
           launchCamera(options, permissionRequestCallback);
-          break;
+          return true;
 
         case REQUEST_PERMISSIONS_FOR_LIBRARY:
+          // Open the picker whether or not media location was granted; without it we simply
+          // won't get EXIF GPS back.
+          mediaLocationRequested = true;
           launchImageLibrary(options, permissionRequestCallback);
-          break;
-
+          return true;
       }
-      return true;
+      return false;
     }
   };
 
@@ -152,23 +158,22 @@ public class ImagePickerModule extends ReactContextBaseJavaModule
 
   @ReactMethod
   public void showImagePicker(final ReadableMap options, final Callback callback) {
+    final ImagePickerModule self = this;
+    final Activity currentActivity = getReactApplicationContext().getCurrentActivity();
     Handler handler = new Handler(this.reactContext.getMainLooper());
+    this.callback = callback;
+    this.options = options;
+    if (currentActivity == null)
+    {
+      responseHelper.invokeError(callback, "can't find current Activity");
+      return;
+    }
+    imageConfig = new ImageConfig(0, 0, 100, 0, false);
     handler.post(new Runnable() {
       @Override
       public void run() {
-        Activity currentActivity = getCurrentActivity();
-
-        if (currentActivity == null)
-        {
-          responseHelper.invokeError(callback, "can't find current Activity");
-          return;
-        }
-
-        this.callback = callback;
-        this.options = options;
-        imageConfig = new ImageConfig(0, 0, 100, 0, false);
 
-        final AlertDialog dialog = UI.chooseDialog(this, options, new UI.OnAction()
+        final AlertDialog dialog = UI.chooseDialog(self, options, new UI.OnAction()
         {
           @Override
           public void onTakePhoto(@NonNull final ImagePickerModule module)
@@ -233,34 +238,35 @@ public class ImagePickerModule extends ReactContextBaseJavaModule
   @ReactMethod
   public void launchCamera(final ReadableMap options, final Callback callback)
   {
-    Handler handler = new Handler(this.reactContext.getMainLooper());
-    handler.post(new Runnable() {
-                   @Override
-                   public void run() {
-                     permissionRequestCallback = callback;
+    final ImagePickerModule self = this;
+    Handler handler = new Handler(this.getContext().getMainLooper());
+    permissionRequestCallback = callback;
 
-                     if (!isCameraAvailable())
-                     {
-                       responseHelper.invokeError(callback, "Camera not available");
-                       return;
-                     }
+    if (!isCameraAvailable())
+    {
+      responseHelper.invokeError(callback, "Camera not available");
+      return;
+    }
 
-                     final Activity currentActivity = getCurrentActivity();
-                     if (currentActivity == null)
-                     {
-                       responseHelper.invokeError(callback, "can't find current Activity");
-                       return;
-                     }
+    final Activity currentActivity = getReactApplicationContext().getCurrentActivity();
+    if (currentActivity == null)
+    {
+      responseHelper.invokeError(callback, "can't find current Activity");
+      return;
+    }
 
-                     this.callback = callback;
-                     this.options = options;
+    this.callback = callback;
+    this.options = options;
 
+    handler.post(new Runnable() {
+                   @Override
+                   public void run() {
                      if (!permissionsCheck(currentActivity, callback, REQUEST_PERMISSIONS_FOR_CAMERA))
                      {
                        return;
                      }
 
-                     parseOptions(this.options);
+                     parseOptions(options);
 
                      int requestCode;
                      Intent cameraIntent;
@@ -280,10 +286,10 @@ public class ImagePickerModule extends ReactContextBaseJavaModule
                        requestCode = REQUEST_LAUNCH_IMAGE_CAPTURE;
                        cameraIntent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
 
-                       final File original = createNewFile(reactContext, this.options, false);
+                       final File original = createNewFile(self.getContext(), options, false);
 
                        if (original != null) {
-                         cameraCaptureURI = RealPathUtil.compatUriFromFile(reactContext, original);
+                         cameraCaptureURI = RealPathUtil.compatUriFromFile(self.getContext(), original);
                        }else {
                          responseHelper.invokeError(callback, "Couldn't get file path for photo");
                          return;
@@ -296,16 +302,7 @@ public class ImagePickerModule extends ReactContextBaseJavaModule
                        cameraIntent.putExtra(MediaStore.EXTRA_OUTPUT, cameraCaptureURI);
                      }
 
-                     // Workaround for Android bug.
-                     // grantUriPermission also needed for KITKAT,
-                     // see https://code.google.com/p/android/issues/detail?id=76683
-                     if (Build.VERSION.SDK_INT <= Build.VERSION_CODES.KITKAT) {
-                       List<ResolveInfo> resInfoList = reactContext.getPackageManager().queryIntentActivities(cameraIntent, PackageManager.MATCH_DEFAULT_ONLY);
-                       for (ResolveInfo resolveInfo : resInfoList) {
-                         String packageName = resolveInfo.activityInfo.packageName;
-                         reactContext.grantUriPermission(packageName, cameraCaptureURI, Intent.FLAG_GRANT_WRITE_URI_PERMISSION | Intent.FLAG_GRANT_READ_URI_PERMISSION);
-                       }
-                     }
+                     cameraIntent.addFlags(Intent.FLAG_GRANT_WRITE_URI_PERMISSION | Intent.FLAG_GRANT_READ_URI_PERMISSION);
 
                      try
                      {
@@ -328,62 +325,55 @@ public class ImagePickerModule extends ReactContextBaseJavaModule
   @ReactMethod
   public void launchImageLibrary(final ReadableMap options, final Callback callback)
   {
-    Handler handler = new Handler(this.reactContext.getMainLooper());
-    handler.post(new Runnable() {
-      @Override
-      public void run(){
-        permissionRequestCallback = callback;
+    permissionRequestCallback = callback;
 
-        final Activity currentActivity = getCurrentActivity();
-        if (currentActivity == null) {
-          responseHelper.invokeError(callback, "can't find current Activity");
-          return;
-        }
+    final Activity currentActivity = getReactApplicationContext().getCurrentActivity();
+    if (currentActivity == null) {
+      responseHelper.invokeError(callback, "can't find current Activity");
+      return;
+    }
 
-        this.callback = callback;
-        this.options = options;
+    this.callback = callback;
+    this.options = options;
 
-        if (!permissionsCheck(currentActivity, callback, REQUEST_PERMISSIONS_FOR_LIBRARY))
+    Handler handler = new Handler(this.getContext().getMainLooper());
+    handler.post(new Runnable() {
+      @Override
+      public void run(){
+        if (shouldRequestMediaLocation(currentActivity))
         {
+          requestPermissions(currentActivity, new String[]{Manifest.permission.ACCESS_MEDIA_LOCATION}, REQUEST_PERMISSIONS_FOR_LIBRARY);
           return;
         }
+        mediaLocationRequested = false;
 
-        parseOptions(this.options);
+        parseOptions(options);
 
-        int requestCode;
-        Intent libraryIntent;
+        // System Photo Picker (Android 13+, or back-ported via Google Play services). androidx falls
+        // back to ACTION_OPEN_DOCUMENT on devices where neither is available.
+        final ActivityResultContracts.PickVisualMedia.VisualMediaType mediaType;
         if (pickVideo)
         {
-          requestCode = REQUEST_LAUNCH_VIDEO_LIBRARY;
-          libraryIntent = new Intent(Intent.ACTION_GET_CONTENT);
-          libraryIntent.setType("video/*");
-          libraryIntent.putExtra(Intent.EXTRA_LOCAL_ONLY, true);
-          libraryIntent.putExtra(Intent.CATEGORY_OPENABLE, true);
+          mediaType = ActivityResultContracts.PickVisualMedia.VideoOnly.INSTANCE;
+        }
+        else if (pickBoth)
+        {
+          mediaType = ActivityResultContracts.PickVisualMedia.ImageAndVideo.INSTANCE;
         }
         else
         {
-          requestCode = REQUEST_LAUNCH_IMAGE_LIBRARY;
-          libraryIntent = new Intent(Intent.ACTION_GET_CONTENT);
-          libraryIntent.putExtra(Intent.EXTRA_LOCAL_ONLY, true);
-          libraryIntent.putExtra(Intent.CATEGORY_OPENABLE, true);
-
-          if (pickBoth)
-          {
-            libraryIntent.setType("image/* video/*");
-          } else {
-            libraryIntent.setType("image/*");
-          }
+          mediaType = ActivityResultContracts.PickVisualMedia.ImageOnly.INSTANCE;
         }
+        final PickVisualMediaRequest request = new PickVisualMediaRequest.Builder()
+                .setMediaType(mediaType)
+                .build();
+        final Intent libraryIntent = new ActivityResultContracts.PickVisualMedia()
+                .createIntent(currentActivity, request);
+        final int requestCode = pickVideo ? REQUEST_LAUNCH_VIDEO_LIBRARY : REQUEST_LAUNCH_IMAGE_LIBRARY;
 
         try
         {
-          String chooseWhichLibraryTitle = null;
-          if (ReadableMapUtils.hasAndNotEmptyString(options, "chooseWhichLibraryTitle"))
-          {
-            chooseWhichLibraryTitle = options.getString("chooseWhichLibraryTitle");
-          }
-
-          currentActivity.startActivityForResult(Intent.createChooser(libraryIntent, chooseWhichLibraryTitle), requestCode);
+          currentActivity.startActivityForResult(libraryIntent, requestCode);
         }
         catch (ActivityNotFoundException e)
         {
@@ -394,13 +384,28 @@ public class ImagePickerModule extends ReactContextBaseJavaModule
     });
   }
 
+  /**
+   * Ask for ACCESS_MEDIA_LOCATION once per library launch when it isn't granted yet. If the user has
+   * already denied it permanently the request returns immediately without UI.
+   */
+  private boolean shouldRequestMediaLocation(@NonNull final Activity activity)
+  {
+    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.Q || mediaLocationRequested)
+    {
+      return false;
+    }
+    return ActivityCompat.checkSelfPermission(activity, Manifest.permission.ACCESS_MEDIA_LOCATION)
+            != PackageManager.PERMISSION_GRANTED;
+  }
+
   @Override
-  public void onActivityResult(Activity activity, int requestCode, int resultCode, Intent data) {
-    Handler handler = new Handler(this.reactContext.getMainLooper());
+  public void onActivityResult(Activity activity, final int requestCode, final int resultCode, final Intent data) {
+    final ImagePickerModule self = this;
+    Handler handler = new Handler(this.getContext().getMainLooper());
     handler.post(new Runnable() {
       @Override
       public void run() {
-        if (passResult(requestCode))
+        if (self.passResult(requestCode))
         {
           return;
         }
@@ -416,6 +421,7 @@ public class ImagePickerModule extends ReactContextBaseJavaModule
         }
 
         Uri uri = null;
+        boolean fromLibrary = false;
         switch (requestCode)
         {
           case REQUEST_LAUNCH_IMAGE_CAPTURE:
@@ -423,35 +429,44 @@ public class ImagePickerModule extends ReactContextBaseJavaModule
             break;
 
           case REQUEST_LAUNCH_IMAGE_LIBRARY:
-            uri = data.getData();
-            if(uri == null){
-              responseHelper.putString("error", "Could not read photo");
+            uri = data != null ? data.getData() : null;
+            if (uri == null) {
+              responseHelper.invokeError(callback, "Could not read photo");
+              callback = null;
+              return;
+            }
+            // mediaType "mixed" can hand back a video from the image request code.
+            final String mimeType = self.getContext().getContentResolver().getType(uri);
+            if (mimeType != null && mimeType.startsWith("video/")) {
+              responseHelper.putString("uri", uri.toString());
               responseHelper.invokeResponse(callback);
               callback = null;
               return;
             }
+            fromLibrary = true;
             break;
 
           case REQUEST_LAUNCH_VIDEO_LIBRARY:
-            responseHelper.putString("uri", data.getData().toString());
-            responseHelper.invokeResponse(callback);
-            callback = null;
-            return;
-
           case REQUEST_LAUNCH_VIDEO_CAPTURE:
+            if (data == null || data.getData() == null) {
+              responseHelper.invokeError(callback, "Could not read video");
+              callback = null;
+              return;
+            }
             responseHelper.putString("uri", data.getData().toString());
             responseHelper.invokeResponse(callback);
             callback = null;
             return;
         }
 
+        // EXIF (location/timestamp/orientation). For library picks, ask for the unredacted original
+        // so GPS survives when ACCESS_MEDIA_LOCATION is granted and the provider honours it.
         ReadExifResult result = null;
-        try {
-          InputStream imageInputStream = reactContext.getContentResolver().openInputStream(uri);
-          if(imageInputStream != null){
+        try (InputStream imageInputStream = openExifInputStream(uri, fromLibrary)) {
+          if (imageInputStream != null) {
             result = readExifInterface(imageInputStream, responseHelper);
           }
-        } catch(IOException ex){
+        } catch (IOException ex) {
           responseHelper.invokeError(callback, ex.getMessage());
           callback = null;
           return;
@@ -470,31 +485,26 @@ public class ImagePickerModule extends ReactContextBaseJavaModule
 
         BitmapFactory.Options options = new BitmapFactory.Options();
         options.inJustDecodeBounds = true;
-        Bitmap imageBitmap = null;
-        try {
-          InputStream imageInputStream = reactContext.getContentResolver().openInputStream(uri);
-          imageBitmap = BitmapFactory.decodeStream(imageInputStream, null, options);
-        } catch(FileNotFoundException ex){
+        try (InputStream imageInputStream = self.getContext().getContentResolver().openInputStream(uri)) {
+          BitmapFactory.decodeStream(imageInputStream, null, options);
+        } catch (IOException ex) {
           responseHelper.invokeError(callback, "Could not find file");
           callback = null;
           return;
         }
 
-
         int initialWidth = options.outWidth;
         int initialHeight = options.outHeight;
 
-
         // don't create a new file if contraint are respected
         if (imageConfig.useOriginal(initialWidth, initialHeight, result.currentRotation))
         {
           responseHelper.putInt("width", initialWidth);
           responseHelper.putInt("height", initialHeight);
 
-          try {
-            InputStream imageInputStream = reactContext.getContentResolver().openInputStream(uri);
+          try (InputStream imageInputStream = self.getContext().getContentResolver().openInputStream(uri)) {
             updatedResultResponse(imageInputStream);
-          } catch(FileNotFoundException ex){
+          } catch (IOException ex) {
             responseHelper.invokeError(callback, "Could not find file");
             callback = null;
             return;
@@ -504,10 +514,9 @@ public class ImagePickerModule extends ReactContextBaseJavaModule
         {
           Bitmap resizedImage = null;
           ImageConfig rotatedImageConfig = imageConfig.withRotation(result.currentRotation);
-          try {
-            InputStream imageInputStream = reactContext.getContentResolver().openInputStream(uri);
+          try (InputStream imageInputStream = self.getContext().getContentResolver().openInputStream(uri)) {
             resizedImage = getResizedImage(imageInputStream, rotatedImageConfig, initialWidth, initialHeight);
-          } catch(FileNotFoundException ex){
+          } catch (IOException ex) {
             responseHelper.invokeError(callback, "Could not find file");
             callback = null;
             return;
@@ -527,22 +536,38 @@ public class ImagePickerModule extends ReactContextBaseJavaModule
             ByteArrayInputStream bs = new ByteArrayInputStream(bitmapdata);
             updatedResultResponse(bs);
             resizedImage.recycle();
-            resizedImage = null;
           }
         }
-        if(imageBitmap != null){
-          imageBitmap.recycle();
-          imageBitmap = null;
-        }
-
 
         responseHelper.invokeResponse(callback);
-        callback = null;
-        this.options = null;
+        self.callback = null;
+        self.options = null;
       }
     });
   }
 
+  /**
+   * Open a stream for EXIF parsing. On Android 10+ location tags are redacted unless we hold
+   * ACCESS_MEDIA_LOCATION and ask for the original via MediaStore.setRequireOriginal. Providers that
+   * don't support that (e.g. some Photo Picker configurations) throw, in which case we fall back to the
+   * plain (redacted) stream.
+   */
+  private @Nullable InputStream openExifInputStream(@NonNull final Uri uri, final boolean fromLibrary) throws FileNotFoundException
+  {
+    if (fromLibrary && Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q)
+    {
+      try
+      {
+        return getContext().getContentResolver().openInputStream(MediaStore.setRequireOriginal(uri));
+      }
+      catch (UnsupportedOperationException | SecurityException | IllegalArgumentException | FileNotFoundException e)
+      {
+        // fall through to the plain uri
+      }
+    }
+    return getContext().getContentResolver().openInputStream(uri);
+  }
+
   public void invokeCustomButton(@NonNull final String action)
   {
     responseHelper.invokeCustomButton(this.callback, action);
@@ -563,7 +588,7 @@ public class ImagePickerModule extends ReactContextBaseJavaModule
 
   public @NonNull Activity getActivity()
   {
-    return getCurrentActivity();
+    return getReactApplicationContext().getCurrentActivity();
   }
 
 
@@ -583,130 +608,89 @@ public class ImagePickerModule extends ReactContextBaseJavaModule
                                    @NonNull final Callback callback,
                                    @NonNull final int requestCode)
   {
-    int writePermission = 0;
-    int libraryPermission = 0;
-    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.TIRAMISU) {
-      writePermission = ActivityCompat.checkSelfPermission(activity, Manifest.permission.WRITE_EXTERNAL_STORAGE);
-      libraryPermission = writePermission;
-    } else {
-      writePermission = PackageManager.PERMISSION_GRANTED;
-      libraryPermission = ActivityCompat.checkSelfPermission(activity, Manifest.permission.READ_MEDIA_IMAGES);
-    }
-
-    final int cameraPermission = ActivityCompat
-            .checkSelfPermission(activity, Manifest.permission.CAMERA);
-
-    boolean permissionsGranted = false;
-
-    switch (requestCode) {
-      case REQUEST_PERMISSIONS_FOR_LIBRARY:
-        permissionsGranted = libraryPermission == PackageManager.PERMISSION_GRANTED;
-        break;
-      case REQUEST_PERMISSIONS_FOR_CAMERA:
-        permissionsGranted = cameraPermission == PackageManager.PERMISSION_GRANTED && writePermission == PackageManager.PERMISSION_GRANTED;
-        break;
+    // Only the camera needs a runtime permission. Captures are written to app-specific storage
+    // (getExternalFilesDir) and the library uses the system Photo Picker, so no storage permission
+    // is required on any supported API level.
+    final boolean permissionsGranted = ActivityCompat
+            .checkSelfPermission(activity, Manifest.permission.CAMERA) == PackageManager.PERMISSION_GRANTED;
+    if (permissionsGranted)
+    {
+      return true;
     }
 
-    if (!permissionsGranted)
+    if (ActivityCompat.shouldShowRequestPermissionRationale(activity, Manifest.permission.CAMERA))
     {
-      Boolean dontAskAgain = false;
-      if (Build.VERSION.SDK_INT < Build.VERSION_CODES.TIRAMISU) {
-        dontAskAgain = ActivityCompat.shouldShowRequestPermissionRationale(activity, Manifest.permission.WRITE_EXTERNAL_STORAGE) && ActivityCompat.shouldShowRequestPermissionRationale(activity, Manifest.permission.CAMERA);
-      } else {
-        dontAskAgain = ActivityCompat.shouldShowRequestPermissionRationale(activity, Manifest.permission.READ_MEDIA_IMAGES) && ActivityCompat.shouldShowRequestPermissionRationale(activity, Manifest.permission.CAMERA);
-      }
-
-      if (dontAskAgain)
-      {
-        final AlertDialog dialog = PermissionUtils
-                .explainingDialog(this, options, new PermissionUtils.OnExplainingPermissionCallback()
+      final AlertDialog dialog = PermissionUtils
+              .explainingDialog(this, options, new PermissionUtils.OnExplainingPermissionCallback()
+              {
+                @Override
+                public void onCancel(WeakReference<ImagePickerModule> moduleInstance,
+                                     DialogInterface dialogInterface)
                 {
-                  @Override
-                  public void onCancel(WeakReference<ImagePickerModule> moduleInstance,
-                                       DialogInterface dialogInterface)
+                  final ImagePickerModule module = moduleInstance.get();
+                  if (module == null)
                   {
-                    final ImagePickerModule module = moduleInstance.get();
-                    if (module == null)
-                    {
-                      return;
-                    }
-                    module.doOnCancel();
+                    return;
                   }
+                  module.doOnCancel();
+                }
 
-                  @Override
-                  public void onReTry(WeakReference<ImagePickerModule> moduleInstance,
-                                      DialogInterface dialogInterface)
+                @Override
+                public void onReTry(WeakReference<ImagePickerModule> moduleInstance,
+                                    DialogInterface dialogInterface)
+                {
+                  final ImagePickerModule module = moduleInstance.get();
+                  if (module == null)
                   {
-                    final ImagePickerModule module = moduleInstance.get();
-                    if (module == null)
-                    {
-                      return;
-                    }
-                    Intent intent = new Intent(Settings.ACTION_APPLICATION_DETAILS_SETTINGS);
-                    Uri uri = Uri.fromParts("package", module.getContext().getPackageName(), null);
-                    intent.setData(uri);
-                    final Activity innerActivity = module.getActivity();
-                    if (innerActivity == null)
-                    {
-                      return;
-                    }
-                    innerActivity.startActivityForResult(intent, 1);
+                    return;
                   }
-                });
-        if (dialog != null) {
-          dialog.show();
-        }
-        return false;
+                  Intent intent = new Intent(Settings.ACTION_APPLICATION_DETAILS_SETTINGS);
+                  Uri uri = Uri.fromParts("package", module.getContext().getPackageName(), null);
+                  intent.setData(uri);
+                  final Activity innerActivity = module.getActivity();
+                  if (innerActivity == null)
+                  {
+                    return;
+                  }
+                  innerActivity.startActivityForResult(intent, 1);
+                }
+              });
+      if (dialog != null) {
+        dialog.show();
       }
-      else
-      {
-        String[] PERMISSIONS;
-        switch (requestCode) {
-          case REQUEST_PERMISSIONS_FOR_LIBRARY:
-            if (Build.VERSION.SDK_INT < Build.VERSION_CODES.TIRAMISU) {
-              PERMISSIONS = new String[]{Manifest.permission.WRITE_EXTERNAL_STORAGE};
-            } else {
-              PERMISSIONS = new String[]{Manifest.permission.READ_MEDIA_IMAGES};
-            }
-            break;
-          case REQUEST_PERMISSIONS_FOR_CAMERA:
-            if (Build.VERSION.SDK_INT < Build.VERSION_CODES.TIRAMISU) {
-              PERMISSIONS = new String[]{Manifest.permission.CAMERA,Manifest.permission.WRITE_EXTERNAL_STORAGE};
-            } else {
-              PERMISSIONS = new String[]{Manifest.permission.CAMERA};
-            }
-            break;
-          default:
-            PERMISSIONS = new String[]{};
-            break;
-        }
+      return false;
+    }
 
-        if (activity instanceof ReactActivity)
-        {
-          ((ReactActivity) activity).requestPermissions(PERMISSIONS, requestCode, listener);
-        }
-        else if (activity instanceof PermissionAwareActivity) {
-          ((PermissionAwareActivity) activity).requestPermissions(PERMISSIONS, requestCode, listener);
-        }
-        else if (activity instanceof OnImagePickerPermissionsCallback)
-        {
-          ((OnImagePickerPermissionsCallback) activity).setPermissionListener(listener);
-          ActivityCompat.requestPermissions(activity, PERMISSIONS, requestCode);
-        }
-        else
-        {
-          final String errorDescription = new StringBuilder(activity.getClass().getSimpleName())
-                  .append(" must implement ")
-                  .append(OnImagePickerPermissionsCallback.class.getSimpleName())
-                  .append(" or ")
-                  .append(PermissionAwareActivity.class.getSimpleName())
-                  .toString();
-          throw new UnsupportedOperationException(errorDescription);
-        }
-        return false;
-      }
+    requestPermissions(activity, new String[]{Manifest.permission.CAMERA}, requestCode);
+    return false;
+  }
+
+  private void requestPermissions(@NonNull final Activity activity,
+                                  @NonNull final String[] permissions,
+                                  final int requestCode)
+  {
+    if (activity instanceof ReactActivity)
+    {
+      ((ReactActivity) activity).requestPermissions(permissions, requestCode, listener);
+    }
+    else if (activity instanceof PermissionAwareActivity) {
+      ((PermissionAwareActivity) activity).requestPermissions(permissions, requestCode, listener);
+    }
+    else if (activity instanceof OnImagePickerPermissionsCallback)
+    {
+      ((OnImagePickerPermissionsCallback) activity).setPermissionListener(listener);
+      ActivityCompat.requestPermissions(activity, permissions, requestCode);
+    }
+    else
+    {
+      final String errorDescription = new StringBuilder(activity.getClass().getSimpleName())
+              .append(" must implement ")
+              .append(OnImagePickerPermissionsCallback.class.getSimpleName())
+              .append(" or ")
+              .append(PermissionAwareActivity.class.getSimpleName())
+              .toString();
+      throw new UnsupportedOperationException(errorDescription);
     }
-    return true;
   }
 
   private boolean isCameraAvailable() {