react-native-compressor 1.3.3 → 1.4.1-alpha

package/README.md

@@ -24,7 +24,7 @@
 
 **react-native-compressor** package is a set of functions that allow you compress `Image`,`Audio` and `Video`
 
-If you find this package useful hit the star 🌟
+**If you find this package useful hit the star** 🌟
 
 ## Installation
 
@@ -33,7 +33,7 @@ If you find this package useful hit the star 🌟
 #### For React Native<0.65
 
 ```sh
-yarn add react-native-compressor@0.5.11
+yarn add react-native-compressor@0.5.15
 ```
 
 #### For React Native 0.65 or greater
@@ -334,6 +334,57 @@ type FileSystemUploadOptions = (
 };
 ```
 
+### Get Metadata Of Video
+
+if you want to get metadata of video than you can use this function
+
+```js
+import { getVideoMetaData } from 'react-native-compressor';
+
+const metaData = await getVideoMetaData(filePath);
+```
+
+```
+{
+	"duration": "6",
+	"extension": "mp4",
+	"height": "1080",
+	"size": "16940.0",
+	"width": "1920"
+}
+```
+
+- ###### `getVideoMetaData(path: string)`
+
+### Get Real Path
+
+if you want to convert
+
+- `content://` to `file:///` for android
+- `ph://` to `file:///` for IOS
+
+the you can you `getRealPath` function like this
+
+```js
+import { getRealPath } from 'react-native-compressor';
+
+const realPath = await getRealPath(fileUri, 'video'); //   file://file_path.extension
+```
+
+- ###### `getRealPath(path: string, type: string = 'video'|'image')`
+
+### Get Temp file Path
+
+if you wanna make random file path in cache folder then you can use this method like this
+
+```js
+import { generateFilePath } from 'react-native-compressor';
+
+const randomFilePathForSaveFile = await generateFilePath('mp4'); //   file://file_path.mp4
+```
+
+- ##### `generateFilePath(fileextension: string)`
+
 ## Contributing
 
 See the [contributing guide](CONTRIBUTING.md) to learn how to contribute to the repository and the development workflow.

package/android/.gradle/buildOutputCleanup/cache.properties

@@ -1,2 +1,2 @@
-#Mon Dec 20 15:53:04 PKT 2021
+#Thu Jan 27 18:54:59 PKT 2022
 gradle.version=6.9

package/android/build.gradle

@@ -57,6 +57,6 @@ dependencies {
     //noinspection GradleDynamicVersion
   implementation "com.facebook.react:react-native:+"  // From node_modules
   implementation 'io.github.lizhangqu:coreprogress:1.0.2'
-  implementation 'com.github.nomi9995:VideoCompressor:43ec740572'
+  implementation 'com.github.nomi9995:VideoCompressor:715bcc16e9'
 //   implementation project(path: ':videocompressor')
 }

package/android/src/main/java/com/reactnativecompressor/CompressorModule.java

@@ -9,6 +9,7 @@ import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
 import androidx.annotation.RequiresApi;
 
+import com.facebook.react.bridge.Arguments;
 import com.facebook.react.bridge.Promise;
 import com.facebook.react.bridge.ReactApplicationContext;
 import com.facebook.react.bridge.ReactContext;
@@ -20,10 +21,15 @@ import com.facebook.react.module.annotations.ReactModule;
 import com.facebook.react.modules.core.DeviceEventManagerModule;
 import com.reactnativecompressor.Image.ImageCompressor;
 import com.reactnativecompressor.Image.utils.ImageCompressorOptions;
+import com.reactnativecompressor.Utils.Utils;
 import com.reactnativecompressor.Video.VideoCompressorHelper;
 import static com.reactnativecompressor.Utils.Utils.generateCacheFilePath;
+import static com.reactnativecompressor.Utils.Utils.getRealPath;
+
 import com.reactnativecompressor.Audio.AudioCompressor;
 
+import java.io.File;
+
 @ReactModule(name = CompressorModule.NAME)
 public class CompressorModule extends ReactContextBaseJavaModule {
     public static final String NAME = "Compressor";
@@ -54,6 +60,7 @@ public class CompressorModule extends ReactContextBaseJavaModule {
     ReadableMap optionMap,
     Promise promise) {
     try {
+      imagePath=Utils.getRealPath(imagePath,reactContext);
       final ImageCompressorOptions options = ImageCompressorOptions.fromMap(optionMap);
 
       if(options.compressionMethod==ImageCompressorOptions.CompressionMethod.auto)
@@ -98,7 +105,7 @@ public class CompressorModule extends ReactContextBaseJavaModule {
 
   //General
     @ReactMethod
-   public void generateFile(String extension, Promise promise) {
+   public void generateFilePath(String extension, Promise promise) {
      try {
        final String outputUri =generateCacheFilePath(extension,reactContext);
        promise.resolve(outputUri);
@@ -106,4 +113,42 @@ public class CompressorModule extends ReactContextBaseJavaModule {
        promise.reject(e);
      }
    }
+
+  @ReactMethod
+  public void getRealPath(String path,String type, Promise promise) {
+    try {
+      final String realPath =Utils.getRealPath(path,reactContext);
+      promise.resolve("file://"+realPath);
+    } catch (Exception e) {
+      promise.reject(e);
+    }
+  }
+
+  @ReactMethod
+  public void getVideoMetaData(String filePath, Promise promise) {
+    try {
+      filePath=Utils.getRealPath(filePath,reactContext);
+      Uri uri= Uri.parse(filePath);
+      String srcPath = uri.getPath();
+      MediaMetadataRetriever metaRetriever = new MediaMetadataRetriever();
+      metaRetriever.setDataSource(srcPath);
+      File file=new File(srcPath);
+      float sizeInKBs = file.length()/1024;
+      int actualHeight =Integer.parseInt(metaRetriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_VIDEO_HEIGHT));
+      int actualWidth = Integer.parseInt(metaRetriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_VIDEO_WIDTH));
+      long duration = Long.parseLong(metaRetriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_DURATION));
+      String extension = filePath.substring(filePath.lastIndexOf(".")+1);
+
+      WritableMap params = Arguments.createMap();
+      params.putString("size", String.valueOf(sizeInKBs));
+      params.putString("width", String.valueOf(actualWidth));
+      params.putString("height", String.valueOf(actualHeight));
+      params.putString("duration", String.valueOf(duration/1000));
+      params.putString("extension", extension);
+
+      promise.resolve(params);
+    } catch (Exception e) {
+      promise.reject(e);
+    }
+  }
 }

package/android/src/main/java/com/reactnativecompressor/Utils/RealPathUtil.java

@@ -0,0 +1,210 @@
+package com.reactnativecompressor.Utils;
+
+import android.annotation.SuppressLint;
+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 androidx.loader.content.CursorLoader;
+
+public class RealPathUtil {
+
+  public static String getRealPath(Context context, Uri fileUri) {
+    String realPath;
+    // SDK < API11
+    if (Build.VERSION.SDK_INT < 11) {
+      realPath = RealPathUtil.getRealPathFromURI_BelowAPI11(context, fileUri);
+    }
+    // SDK >= 11 && SDK < 19
+    else if (Build.VERSION.SDK_INT < 19) {
+      realPath = RealPathUtil.getRealPathFromURI_API11to18(context, fileUri);
+    }
+    // SDK > 19 (Android 4.4) and up
+    else {
+      realPath = RealPathUtil.getRealPathFromURI_API19(context, fileUri);
+    }
+    return realPath;
+  }
+
+
+  @SuppressLint("NewApi")
+  public static String getRealPathFromURI_API11to18(Context context, Uri contentUri) {
+    String[] proj = {MediaStore.Images.Media.DATA};
+    String result = null;
+
+    CursorLoader cursorLoader = new CursorLoader(context, contentUri, proj, null, null, null);
+    Cursor cursor = cursorLoader.loadInBackground();
+
+    if (cursor != null) {
+      int column_index = cursor.getColumnIndexOrThrow(MediaStore.Images.Media.DATA);
+      cursor.moveToFirst();
+      result = cursor.getString(column_index);
+      cursor.close();
+    }
+    return result;
+  }
+
+  public static String getRealPathFromURI_BelowAPI11(Context context, Uri contentUri) {
+    String[] proj = {MediaStore.Images.Media.DATA};
+    Cursor cursor = context.getContentResolver().query(contentUri, proj, null, null, null);
+    int column_index = 0;
+    String result = "";
+    if (cursor != null) {
+      column_index = cursor.getColumnIndexOrThrow(MediaStore.Images.Media.DATA);
+      cursor.moveToFirst();
+      result = cursor.getString(column_index);
+      cursor.close();
+      return result;
+    }
+    return result;
+  }
+
+  /**
+   * Get a file path from a Uri. This will get the the path for Storage Access
+   * Framework Documents, as well as the _data field for the MediaStore and
+   * other file-based ContentProviders.
+   *
+   * @param context The context.
+   * @param uri     The Uri to query.
+   * @author paulburke
+   */
+  @SuppressLint("NewApi")
+  public static String getRealPathFromURI_API19(final Context context, final Uri uri) {
+
+    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];
+        }
+
+        // TODO handle non-primary volumes
+      }
+      // 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;
+  }
+
+  /**
+   * 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.
+   */
+  public static String getDataColumn(Context context, Uri uri, String selection,
+                                     String[] selectionArgs) {
+
+    Cursor cursor = null;
+    final String column = "_data";
+    final String[] projection = {
+      column
+    };
+
+    try {
+      cursor = context.getContentResolver().query(uri, projection, selection, selectionArgs,
+        null);
+      if (cursor != null && cursor.moveToFirst()) {
+        final int index = cursor.getColumnIndexOrThrow(column);
+        return cursor.getString(index);
+      }
+    } finally {
+      if (cursor != null)
+        cursor.close();
+    }
+    return null;
+  }
+
+
+  /**
+   * @param uri The Uri to check.
+   * @return Whether the Uri authority is ExternalStorageProvider.
+   */
+  public 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.
+   */
+  public 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.
+   */
+  public 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.
+   */
+  public static boolean isGooglePhotosUri(Uri uri) {
+    return "com.google.android.apps.photos.content".equals(uri.getAuthority());
+  }
+
+}

package/android/src/main/java/com/reactnativecompressor/Utils/Utils.java

@@ -1,5 +1,8 @@
 package com.reactnativecompressor.Utils;
 
+import android.net.Uri;
+import android.util.Log;
+
 import androidx.annotation.Nullable;
 
 import com.facebook.react.bridge.Arguments;
@@ -17,7 +20,7 @@ import java.util.UUID;
 
 public class Utils {
   static int videoCompressionThreshold=10;
-  static int currentVideoCompression=0;
+  private static final String TAG = "react-native-compessor";
   static Map<String, VideoCompressTask> compressorExports = new HashMap<>();
 
   public static String generateCacheFilePath(String extension, ReactApplicationContext reactContext){
@@ -29,6 +32,7 @@ public class Utils {
 
 
   public static void compressVideo(String srcPath, String destinationPath, int resultWidth, int resultHeight, float videoBitRate, String uuid, Promise promise, ReactApplicationContext reactContext){
+    final int[] currentVideoCompression = {0};
     try{
       VideoCompressTask export=VideoCompressor.convertVideo(srcPath, destinationPath, resultWidth, resultHeight, (int) videoBitRate, new VideoCompressor.ProgressListener() {
       @Override
@@ -43,20 +47,27 @@ public class Utils {
 
       @Override
       public void onError(String errorMessage) {
-        promise.reject("Compression has canncelled");
+        if(errorMessage.equals(("class java.lang.AssertionError")))
+        {
+          promise.resolve(srcPath);
+        }
+        else
+        {
+          promise.reject("Compression has canncelled");
+        }
       }
 
       @Override
       public void onProgress(float percent) {
         int roundProgress=Math.round(percent);
-        if(roundProgress%videoCompressionThreshold==0&&roundProgress>currentVideoCompression) {
+        if(roundProgress%videoCompressionThreshold==0&&roundProgress> currentVideoCompression[0]) {
           WritableMap params = Arguments.createMap();
           WritableMap data = Arguments.createMap();
           params.putString("uuid", uuid);
           data.putDouble("progress", percent / 100);
           params.putMap("data", data);
           sendEvent(reactContext, "videoCompressProgress", params);
-          currentVideoCompression=roundProgress;
+          currentVideoCompression[0] =roundProgress;
         }
       }
     });
@@ -65,7 +76,7 @@ public class Utils {
     promise.reject(ex);
   }
     finally {
-    currentVideoCompression=0;
+    currentVideoCompression[0] =0;
   }
   }
 
@@ -85,4 +96,18 @@ public class Utils {
       .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
       .emit(eventName, params);
   }
+
+  public static String getRealPath(String fileUrl,ReactApplicationContext reactContext){
+    if(fileUrl.startsWith("content://"))
+    {
+      try {
+        Uri uri= Uri.parse(fileUrl);
+        fileUrl= RealPathUtil.getRealPath(reactContext,uri);
+      }
+      catch (Exception ex) {
+        Log.d(TAG, " Please see this issue: https://github.com/Shobbak/react-native-compressor/issues/25");
+      }
+    }
+    return fileUrl;
+  }
 }

package/android/src/main/java/com/reactnativecompressor/Video/VideoModule.java

@@ -1,5 +1,6 @@
 package com.reactnativecompressor.Video;
 
+import android.net.Uri;
 import android.util.Log;
 
 import androidx.annotation.NonNull;
@@ -14,14 +15,18 @@ import com.facebook.react.bridge.ReadableMap;
 import com.facebook.react.bridge.WritableMap;
 import com.facebook.react.module.annotations.ReactModule;
 import com.facebook.react.modules.core.DeviceEventManagerModule;
+import com.reactnativecompressor.Utils.RealPathUtil;
 
+import static com.reactnativecompressor.Utils.Utils.getRealPath;
 import static com.reactnativecompressor.Video.VideoCompressorHelper.video_activateBackgroundTask_helper;
 import static com.reactnativecompressor.Video.VideoCompressorHelper.video_deactivateBackgroundTask_helper;
 import static com.reactnativecompressor.Video.VideoCompressorHelper.video_upload_helper;
 import static com.reactnativecompressor.Utils.Utils.cancelCompressionHelper;
+
 @ReactModule(name = VideoModule.NAME)
 public class  VideoModule extends ReactContextBaseJavaModule {
   public static final String NAME = "VideoCompressor";
+  private static final String TAG = "react-native-compessor";
   private final ReactApplicationContext reactContext;
   public VideoModule(ReactApplicationContext reactContext) {
     super(reactContext);
@@ -49,6 +54,7 @@ public class  VideoModule extends ReactContextBaseJavaModule {
     ReadableMap optionMap,
     Promise promise) {
     final VideoCompressorHelper options = VideoCompressorHelper.fromMap(optionMap);
+    fileUrl=getRealPath(fileUrl,reactContext);
 
     if(options.compressionMethod==VideoCompressorHelper.CompressionMethod.auto)
     {

package/ios/Compressor-Bridging-Header.h

@@ -3,4 +3,4 @@
 //
 #import <React/RCTBridgeModule.h>
 #import <React/RCTEventEmitter.h>
-
+#import "ImageCompressor.h"