react-native-compressor 1.3.2 → 1.4.0

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.9
+yarn add react-native-compressor@0.5.15
 ```
 
 #### For React Native 0.65 or greater
@@ -176,6 +176,34 @@ const result = await Video.compress(
 );
 ```
 
+##### Cancel Video Compression
+
+```js
+import { Video } from 'react-native-compressor';
+
+let cancellationVideoId = '';
+
+const result = await Video.compress(
+  'file://path_of_file/BigBuckBunny.mp4',
+  {
+    compressionMethod: 'auto',
+    // getCancellationId for get video id which we can use for cancel compression
+    getCancellationId: (cancellationId) =>
+      (cancellationVideoId = cancellationId),
+  },
+  (progress) => {
+    if (backgroundMode) {
+      console.log('Compression Progress: ', progress);
+    } else {
+      setCompressingProgress(progress);
+    }
+  }
+);
+
+// we can cancel video compression by calling cancelCompression with cancel video id which we can get from getCancellationId function while compression
+Video.cancelCompression(cancellationVideoId);
+```
+
 ### Audio
 
 ```js
@@ -247,6 +275,9 @@ const uploadResult = await backgroundUpload(
 
 - ###### `compress(url: string, options?: videoCompresssionType , onProgress?: (progress: number)): Promise<string>`
 
+- ###### `cancelCompression(cancellationId: string): void`
+  we can get cancellationId from `getCancellationId` which is the callback method of compress method options
+
 ### videoCompresssionType
 
 - ###### `compressionMethod: compressionMethod` (default: "manual")
@@ -262,8 +293,12 @@ const uploadResult = await backgroundUpload(
   bitrate of video which reduce or increase video size. if compressionMethod will auto then this prop will not work
 
 - ###### `minimumFileSizeForCompress: number` (default: 16)
+
   16 means 16mb. default our package do not compress under 16mb video file. minimumFileSizeForCompress will allow us to change this 16mb offset. fixed [#26](https://github.com/Shobbak/react-native-compressor/issues/26)
 
+- ###### `getCancellationId: function`
+  `getCancellationId` is a callback function that gives us compress video id, which can be used in `Video.cancelCompression` method to cancel the compression
+
 ## Audio
 
 - ###### `compress(url: string, options?: audioCompresssionType): Promise<string>`
@@ -299,6 +334,29 @@ type FileSystemUploadOptions = (
 };
 ```
 
+# 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 { getRealPath } from 'react-native-compressor';
+
+const realPath = await generateFilePath(fileUri, 'video');        //   file://file_path.extension
+```
+
 ## 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

@@ -56,11 +56,7 @@ repositories {
 dependencies {
     //noinspection GradleDynamicVersion
   implementation "com.facebook.react:react-native:+"  // From node_modules
-  implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:1.4.0"
-  implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.4.0"
-  implementation "com.googlecode.mp4parser:isoparser:1.0.6"
-  implementation 'com.github.zolad:VideoSlimmer:master-SNAPSHOT'
   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/Audio/AudioCompressor.java

@@ -15,7 +15,6 @@ import android.os.Build;
 import androidx.annotation.RequiresApi;
 
 import numan.dev.videocompressor.codecinputsurface.CodecInputSurface;
-
 import java.io.File;
 import java.io.IOException;
 import java.nio.ByteBuffer;

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

@@ -20,9 +20,10 @@ 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 com.reactnativecompressor.Audio.AudioCompressor;
 
 @ReactModule(name = CompressorModule.NAME)
@@ -55,6 +56,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)
@@ -99,7 +101,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);
@@ -107,4 +109,14 @@ 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);
+    }
+  }
 }

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;
@@ -10,7 +13,6 @@ import com.facebook.react.bridge.WritableMap;
 import com.facebook.react.modules.core.DeviceEventManagerModule;
 import numan.dev.videocompressor.VideoCompressTask;
 import numan.dev.videocompressor.VideoCompressor;
-
 import java.io.File;
 import java.util.HashMap;
 import java.util.Map;
@@ -18,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){
@@ -30,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
@@ -44,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;
         }
       }
     });
@@ -66,7 +76,7 @@ public class Utils {
     promise.reject(ex);
   }
     finally {
-    currentVideoCompression=0;
+    currentVideoCompression[0] =0;
   }
   }
 
@@ -86,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/AutoVideoCompression/AutoVideoCompression.java

@@ -1,30 +1,23 @@
 package com.reactnativecompressor.Video.AutoVideoCompression;
 
-import android.media.MediaCodecInfo;
 import android.media.MediaMetadataRetriever;
-import android.media.session.MediaController;
 import android.net.Uri;
-import android.os.Build;
 
 import androidx.annotation.Nullable;
 
-import com.facebook.react.bridge.Arguments;
 import com.facebook.react.bridge.Promise;
 import com.facebook.react.bridge.ReactApplicationContext;
 import com.facebook.react.bridge.ReactContext;
 import com.facebook.react.bridge.WritableMap;
 import com.facebook.react.modules.core.DeviceEventManagerModule;
 import com.reactnativecompressor.Video.VideoCompressorHelper;
-import com.zolad.videoslimmer.VideoSlimmer;
+import static com.reactnativecompressor.Utils.Utils.compressVideo;
 
 import java.io.File;
 
 import static com.reactnativecompressor.Utils.Utils.generateCacheFilePath;
 
 public class AutoVideoCompression {
-  static int videoCompressionThreshold=10;
-  static int currentVideoCompression=0;
-
   public static void createCompressionSettings(String fileUrl,VideoCompressorHelper options,Promise promise, ReactApplicationContext reactContext) {
     float maxSize = options.maxSize;
     float minimumFileSizeForCompress=options.minimumFileSizeForCompress;
@@ -52,43 +45,16 @@ public class AutoVideoCompression {
         bitrate,
         resultHeight, resultWidth
       );
-
-      VideoSlimmer.convertVideo(srcPath, destinationPath, resultWidth, resultHeight, (int) videoBitRate, new VideoSlimmer.ProgressListener() {
-        @Override
-        public void onStart() {
-          //convert start
-        }
-        @Override
-        public void onFinish(boolean result) {
-          //convert finish,result(true is success,false is fail)
-          promise.resolve("file:/"+destinationPath);
-        }
-        @Override
-        public void onProgress(float percent) {
-          int roundProgress=Math.round(percent);
-          if(roundProgress%videoCompressionThreshold==0&&roundProgress>currentVideoCompression) {
-            WritableMap params = Arguments.createMap();
-            WritableMap data = Arguments.createMap();
-            params.putString("uuid", options.uuid);
-            data.putDouble("progress", percent / 100);
-            params.putMap("data", data);
-            sendEvent(reactContext, "videoCompressProgress", params);
-            currentVideoCompression=roundProgress;
-          }
-        }
-      });
-
+      compressVideo(srcPath, destinationPath, resultWidth, resultHeight,  videoBitRate,options.uuid,promise,reactContext);
       }
       else
       {
         promise.resolve(fileUrl);
       }
+
     } catch (Exception ex) {
       promise.reject(ex);
     }
-    finally {
-      currentVideoCompression=0;
-    }
   }
 
   public static int makeVideoBitrate(int originalHeight, int originalWidth, int originalBitrate, int height, int width) {

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

@@ -8,7 +8,6 @@ import android.os.PowerManager;
 
 import androidx.annotation.Nullable;
 
-import com.facebook.react.bridge.Arguments;
 import com.facebook.react.bridge.LifecycleEventListener;
 import com.facebook.react.bridge.Promise;
 import com.facebook.react.bridge.ReactApplicationContext;
@@ -17,13 +16,12 @@ import com.facebook.react.bridge.ReadableMap;
 import com.facebook.react.bridge.ReadableMapKeySetIterator;
 import com.facebook.react.bridge.WritableMap;
 import com.facebook.react.modules.core.DeviceEventManagerModule;
-import com.reactnativecompressor.Image.utils.ImageCompressorOptions;
 import com.reactnativecompressor.Utils.FileUplaoder.FileUploader;
 import com.reactnativecompressor.Video.AutoVideoCompression.AutoVideoCompression;
-import com.zolad.videoslimmer.VideoSlimmer;
 
 import java.util.UUID;
 
+import static com.reactnativecompressor.Utils.Utils.compressVideo;
 import static com.reactnativecompressor.Utils.Utils.generateCacheFilePath;
 
 public class VideoCompressorHelper {
@@ -166,44 +164,10 @@ public class VideoCompressorHelper {
         }
       }
       float videoBitRate = (options.bitrate>0)?options.bitrate: (float) (height * width * 1.5);
-
-      VideoSlimmer.convertVideo(srcPath, destinationPath, width, height, (int) videoBitRate, new VideoSlimmer.ProgressListener() {
-
-
-        @Override
-        public void onStart() {
-          //convert start
-
-        }
-
-        @Override
-        public void onFinish(boolean result) {
-          //convert finish,result(true is success,false is fail)
-          promise.resolve("file:/"+destinationPath);
-        }
-
-
-        @Override
-        public void onProgress(float percent) {
-          int roundProgress=Math.round(percent);
-          if(roundProgress%videoCompressionThreshold==0&&roundProgress>currentVideoCompression) {
-            WritableMap params = Arguments.createMap();
-            WritableMap data = Arguments.createMap();
-            params.putString("uuid", options.uuid);
-            data.putDouble("progress", percent / 100);
-            params.putMap("data", data);
-            sendEvent(reactContext, "videoCompressProgress", params);
-            currentVideoCompression=roundProgress;
-          }
-        }
-      });
-
+      compressVideo(srcPath, destinationPath, width, height,  videoBitRate,options.uuid,promise,reactContext);
     } catch (Exception ex) {
       promise.reject(ex);
     }
-    finally {
-      currentVideoCompression=0;
-    }
   }