Fix exif for android (sdk 30+)

android/src/main/java/com/imagepicker/ImageMetadata.java

@@ -1,33 +1,71 @@
 package com.imagepicker;
 
-import android.content.Context;
-import android.net.Uri;
-import android.util.Log;
-import androidx.exifinterface.media.ExifInterface;
-import java.io.InputStream;
-
-public class ImageMetadata extends Metadata {
-  public ImageMetadata(Uri uri, Context context) {
-    try {
-      InputStream inputStream = context.getContentResolver().openInputStream(uri);
-      ExifInterface exif = new ExifInterface(inputStream);
-      String datetimeTag = exif.getAttribute(ExifInterface.TAG_DATETIME);
-
-      // Extract anymore metadata here...
-      if(datetimeTag != null) this.datetime = getDateTimeInUTC(datetimeTag, "yyyy:MM:dd HH:mm:ss");
-    } catch (Exception e) {
-      // This error does not bubble up to RN as we don't want failed datetime retrieval to prevent selection
-      Log.e("RNIP", "Could not load image metadata: " + e.getMessage());
+import android.media.ExifInterface;
+import android.os.Build;
+
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.bridge.WritableNativeMap;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+import static android.media.ExifInterface.*;
+
+class ImageMetadata {
+
+    static WritableMap extract(String path) throws IOException {
+        WritableMap exifData = new WritableNativeMap();
+
+        List<String> attributes = getBasicAttributes();
+
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+            attributes.addAll(getLevel23Attributes());
+        }
+
+        ExifInterface exif = new ExifInterface(path);
+
+        for (String attribute : attributes) {
+            String value = exif.getAttribute(attribute);
+            exifData.putString(attribute, value);
+        }
+
+        return exifData;
+    }
+
+    private static List<String> getBasicAttributes() {
+        return new ArrayList<>(Arrays.asList(
+                TAG_APERTURE,
+                TAG_DATETIME,
+                TAG_EXPOSURE_TIME,
+                TAG_FLASH,
+                TAG_FOCAL_LENGTH,
+                TAG_GPS_ALTITUDE,
+                TAG_GPS_ALTITUDE_REF,
+                TAG_GPS_DATESTAMP,
+                TAG_GPS_LATITUDE,
+                TAG_GPS_LATITUDE_REF,
+                TAG_GPS_LONGITUDE,
+                TAG_GPS_LONGITUDE_REF,
+                TAG_GPS_PROCESSING_METHOD,
+                TAG_GPS_TIMESTAMP,
+                TAG_IMAGE_LENGTH,
+                TAG_IMAGE_WIDTH,
+                TAG_ISO,
+                TAG_MAKE,
+                TAG_MODEL,
+                TAG_ORIENTATION,
+                TAG_WHITE_BALANCE
+        ));
+    }
+
+    private static List<String> getLevel23Attributes() {
+        return new ArrayList<>(Arrays.asList(
+                TAG_DATETIME_DIGITIZED,
+                TAG_SUBSEC_TIME,
+                TAG_SUBSEC_TIME_DIG,
+                TAG_SUBSEC_TIME_ORIG
+        ));
     }
-  }
-
-  @Override
-  public String getDateTime() { return datetime; }
-
-  // At the moment we are not using the ImageMetadata class to get width/height
-  // TODO: to use this class for extracting image width and height in the future
-  @Override
-  public int getWidth() { return 0; }
-  @Override
-  public int getHeight() { return 0; }
 }

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

@@ -127,39 +127,26 @@ public void launchImageLibrary(final ReadableMap options, final Callback callbac
         Intent libraryIntent;
         requestCode = REQUEST_LAUNCH_LIBRARY;
 
-        int selectionLimit = this.options.selectionLimit;
-        boolean isSingleSelect = selectionLimit == 1;
+        boolean isSingleSelect = this.options.selectionLimit == 1;
         boolean isPhoto = this.options.mediaType.equals(mediaTypePhoto);
         boolean isVideo = this.options.mediaType.equals(mediaTypeVideo);
 
-        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.TIRAMISU) {
-            if (isSingleSelect && (isPhoto || isVideo)) {
-                libraryIntent = new Intent(Intent.ACTION_PICK);
-            } else {
-                libraryIntent = new Intent(Intent.ACTION_GET_CONTENT);
-                libraryIntent.addCategory(Intent.CATEGORY_OPENABLE);
-            }
+        if(isSingleSelect && (isPhoto || isVideo)) {
+            libraryIntent = new Intent(Intent.ACTION_PICK);
         } else {
-            libraryIntent = new Intent(MediaStore.ACTION_PICK_IMAGES);
+            libraryIntent = new Intent(Intent.ACTION_GET_CONTENT);
+            libraryIntent.addCategory(Intent.CATEGORY_OPENABLE);
         }
 
-        if (!isSingleSelect) {
-            if (Build.VERSION.SDK_INT < Build.VERSION_CODES.TIRAMISU) {
-                libraryIntent.putExtra(Intent.EXTRA_ALLOW_MULTIPLE, true);
-            } else {
-                if (selectionLimit != 1) {
-                    int maxNum = selectionLimit;
-                    if (selectionLimit == 0) maxNum = MediaStore.getPickImagesMaxLimit();
-                    libraryIntent.putExtra(MediaStore.EXTRA_PICK_IMAGES_MAX, maxNum);
-                }
-            }
+        if(!isSingleSelect) {
+            libraryIntent.putExtra(Intent.EXTRA_ALLOW_MULTIPLE, true);
         }
 
-        if (isPhoto) {
+        if(isPhoto) {
             libraryIntent.setType("image/*");
         } else if (isVideo) {
             libraryIntent.setType("video/*");
-        } else if (Build.VERSION.SDK_INT < Build.VERSION_CODES.TIRAMISU) {
+        } else {
             libraryIntent.setType("*/*");
             libraryIntent.putExtra(Intent.EXTRA_MIME_TYPES, new String[]{"image/*", "video/*"});
         }

android/src/main/java/com/imagepicker/RealPathUtil.java

@@ -0,0 +1,221 @@
+package com.imagepicker;
+import android.annotation.TargetApi;
+import android.content.ContentUris;
+import android.content.Context;
+import android.database.Cursor;
+import android.net.Uri;
+import android.os.Build;
+import android.os.Environment;
+import android.provider.DocumentsContract;
+import android.provider.MediaStore;
+
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+
+class RealPathUtil {
+    @TargetApi(Build.VERSION_CODES.KITKAT)
+    static String getRealPathFromURI(final Context context, final Uri uri) throws IOException {
+
+        final boolean isKitKat = Build.VERSION.SDK_INT == Build.VERSION_CODES.KITKAT;
+
+        // DocumentProvider
+        if (isKitKat && DocumentsContract.isDocumentUri(context, uri)) {
+            // ExternalStorageProvider
+            if (isExternalStorageDocument(uri)) {
+                final String docId = DocumentsContract.getDocumentId(uri);
+                final String[] split = docId.split(":");
+                final String type = split[0];
+
+                if ("primary".equalsIgnoreCase(type)) {
+                    return Environment.getExternalStorageDirectory() + "/" + split[1];
+                } else {
+                    final int splitIndex = docId.indexOf(':', 1);
+                    final String tag = docId.substring(0, splitIndex);
+                    final String path = docId.substring(splitIndex + 1);
+
+                    String nonPrimaryVolume = getPathToNonPrimaryVolume(context, tag);
+                    if (nonPrimaryVolume != null) {
+                        String result = nonPrimaryVolume + "/" + path;
+                        File file = new File(result);
+                        if (file.exists() && file.canRead()) {
+                            return result;
+                        }
+                        return null;
+                    }
+                }
+            }
+            // DownloadsProvider
+            else if (isDownloadsDocument(uri)) {
+                final String id = DocumentsContract.getDocumentId(uri);
+                final Uri contentUri = ContentUris.withAppendedId(
+                        Uri.parse("content://downloads/public_downloads"), Long.valueOf(id));
+
+                return getDataColumn(context, contentUri, null, null);
+            }
+            // MediaProvider
+            else if (isMediaDocument(uri)) {
+                final String docId = DocumentsContract.getDocumentId(uri);
+                final String[] split = docId.split(":");
+                final String type = split[0];
+
+                Uri contentUri = null;
+                if ("image".equals(type)) {
+                    contentUri = MediaStore.Images.Media.EXTERNAL_CONTENT_URI;
+                } else if ("video".equals(type)) {
+                    contentUri = MediaStore.Video.Media.EXTERNAL_CONTENT_URI;
+                } else if ("audio".equals(type)) {
+                    contentUri = MediaStore.Audio.Media.EXTERNAL_CONTENT_URI;
+                }
+
+                final String selection = "_id=?";
+                final String[] selectionArgs = new String[] {
+                        split[1]
+                };
+
+                return getDataColumn(context, contentUri, selection, selectionArgs);
+            }
+        }
+        // MediaStore (and general)
+        else if ("content".equalsIgnoreCase(uri.getScheme())) {
+            // Return the remote address
+            if (isGooglePhotosUri(uri))
+                return uri.getLastPathSegment();
+            return getDataColumn(context, uri, null, null);
+        }
+        // File
+        else if ("file".equalsIgnoreCase(uri.getScheme())) {
+            return uri.getPath();
+        }
+
+        return null;
+    }
+
+    /**
+     * If an image/video has been selected from a cloud storage, this method
+     * should be call to download the file in the cache folder.
+     *
+     * @param context The context
+     * @param fileName donwloaded file's name
+     * @param uri file's URI
+     * @return file that has been written
+     */
+    private static File writeToFile(Context context, String fileName, Uri uri) {
+        String tmpDir = context.getCacheDir() + "/react-native-image-picker";
+        Boolean created = new File(tmpDir).mkdir();
+        fileName = fileName.substring(fileName.lastIndexOf('/') + 1);
+        File path = new File(tmpDir);
+        File file = new File(path, fileName);
+        try {
+            FileOutputStream oos = new FileOutputStream(file);
+            byte[] buf = new byte[8192];
+            InputStream is = context.getContentResolver().openInputStream(uri);
+            int c = 0;
+            while ((c = is.read(buf, 0, buf.length)) > 0) {
+                oos.write(buf, 0, c);
+                oos.flush();
+            }
+            oos.close();
+            is.close();
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        return file;
+    }
+
+    /**
+     * Get the value of the data column for this Uri. This is useful for
+     * MediaStore Uris, and other file-based ContentProviders.
+     *
+     * @param context The context.
+     * @param uri The Uri to query.
+     * @param selection (Optional) Filter used in the query.
+     * @param selectionArgs (Optional) Selection arguments used in the query.
+     * @return The value of the _data column, which is typically a file path.
+     */
+    private static String getDataColumn(Context context, Uri uri, String selection,
+                                        String[] selectionArgs) {
+
+        Cursor cursor = null;
+        final String[] projection = {
+                MediaStore.MediaColumns.DATA,
+                MediaStore.MediaColumns.DISPLAY_NAME,
+        };
+
+        try {
+            cursor = context.getContentResolver().query(uri, projection, selection, selectionArgs,
+                    null);
+            if (cursor != null && cursor.moveToFirst()) {
+                // Fall back to writing to file if _data column does not exist
+                final int index = cursor.getColumnIndex(MediaStore.MediaColumns.DATA);
+                String path = index > -1 ? cursor.getString(index) : null;
+                if (path != null) {
+                    return cursor.getString(index);
+                } else {
+                    final int indexDisplayName = cursor.getColumnIndexOrThrow(MediaStore.MediaColumns.DISPLAY_NAME);
+                    String fileName = cursor.getString(indexDisplayName);
+                    File fileWritten = writeToFile(context, fileName, uri);
+                    return fileWritten.getAbsolutePath();
+                }
+            }
+        } finally {
+            if (cursor != null)
+                cursor.close();
+        }
+        return null;
+    }
+
+
+    /**
+     * @param uri The Uri to check.
+     * @return Whether the Uri authority is ExternalStorageProvider.
+     */
+    private static boolean isExternalStorageDocument(Uri uri) {
+        return "com.android.externalstorage.documents".equals(uri.getAuthority());
+    }
+
+    /**
+     * @param uri The Uri to check.
+     * @return Whether the Uri authority is DownloadsProvider.
+     */
+    private static boolean isDownloadsDocument(Uri uri) {
+        return "com.android.providers.downloads.documents".equals(uri.getAuthority());
+    }
+
+    /**
+     * @param uri The Uri to check.
+     * @return Whether the Uri authority is MediaProvider.
+     */
+    private static boolean isMediaDocument(Uri uri) {
+        return "com.android.providers.media.documents".equals(uri.getAuthority());
+    }
+
+    /**
+     * @param uri The Uri to check.
+     * @return Whether the Uri authority is Google Photos.
+     */
+    private static boolean isGooglePhotosUri(Uri uri) {
+        return "com.google.android.apps.photos.content".equals(uri.getAuthority());
+    }
+
+    @TargetApi(Build.VERSION_CODES.KITKAT)
+    private static String getPathToNonPrimaryVolume(Context context, String tag) {
+        File[] volumes = context.getExternalCacheDirs();
+        if (volumes != null) {
+            for (File volume : volumes) {
+                if (volume != null) {
+                    String path = volume.getAbsolutePath();
+                    if (path != null) {
+                        int index = path.indexOf(tag);
+                        if (index != -1) {
+                            return path.substring(0, index) + tag;
+                        }
+                    }
+                }
+            }
+        }
+        return null;
+    }
+
+}