react-native-compressor 1.6.4 → 1.7.1

package/android/src/main/java/com/reactnativecompressor/Image/utils/ImageCompressorOptions.java

@@ -33,6 +33,9 @@ public class ImageCompressorOptions {
               case "returnableOutputType":
                 options.returnableOutputType = ReturnableOutputType.valueOf(map.getString(key));
                 break;
+              case "uuid":
+                options.uuid = map.getString(key);
+                break;
             }
         }
 
@@ -55,11 +58,12 @@ public class ImageCompressorOptions {
     auto, manual
   }
 
-    public CompressionMethod compressionMethod = CompressionMethod.manual;
+    public CompressionMethod compressionMethod = CompressionMethod.auto;
     public int maxWidth = 1280;
     public int maxHeight = 1280;
     public float quality = 0.8f;
     public InputType input = InputType.uri;
     public OutputType output = OutputType.jpg;
+    public String uuid = "";
     public ReturnableOutputType returnableOutputType = ReturnableOutputType.uri;
 }

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

@@ -0,0 +1,65 @@
+package com.reactnativecompressor.Utils;
+
+import android.util.Log;
+
+import java.io.File;
+import java.util.ArrayList;
+import java.util.List;
+
+public class MediaCache {
+
+  private static final String TAG = "MediaCache";
+  private static List<String> completedImagePaths = new ArrayList<>();
+
+  public static void addCompletedImagePath(String imagePath) {
+    if (imagePath != null) {
+      // Your code to add the imagePath to a list or perform other actions if needed.
+      completedImagePaths.add(imagePath);
+      Log.d(TAG, "Successfully added image path: " + imagePath);
+    }
+  }
+
+  public static void removeCompletedImagePath(String imagePath) {
+    if (imagePath != null) {
+      if (completedImagePaths.contains(imagePath)) {
+        // Image path exists in the list, so remove it
+        completedImagePaths.remove(imagePath);
+
+        if (imagePath.startsWith("file://")) {
+          imagePath = imagePath.substring(7); // Remove "file://"
+        }
+
+        // Remove the image file
+        File file = new File(imagePath);
+        if (file.exists()) {
+          if (file.delete()) {
+            Log.d(TAG, "Successfully deleted image file: " + imagePath);
+          } else {
+            Log.d(TAG, "Failed to delete image file: " + imagePath);
+          }
+        } else {
+          Log.d(TAG, "Image file not found: " + imagePath);
+        }
+      } else {
+        Log.d(TAG, "Image path not found in the completedImagePaths list: " + imagePath);
+      }
+    }
+  }
+
+  public static void cleanupCache() {
+    // Iterate through the list of completed image paths and delete the corresponding files
+    for (String imagePath : completedImagePaths) {
+      File file = new File(imagePath);
+      if (file.exists()) {
+        if (file.delete()) {
+          Log.d(TAG, "Successfully deleted image file during cache cleanup: " + imagePath);
+        } else {
+          Log.d(TAG, "Failed to delete image file during cache cleanup: " + imagePath);
+        }
+      } else {
+        Log.d(TAG, "Image file not found during cache cleanup: " + imagePath);
+      }
+    }
+    completedImagePaths.clear();
+  }
+}

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

@@ -13,10 +13,26 @@ import com.facebook.react.bridge.WritableMap;
 import com.facebook.react.modules.core.DeviceEventManagerModule;
 import numan.dev.videocompressor.VideoCompressTask;
 import numan.dev.videocompressor.VideoCompressor;
+
+import okhttp3.Call;
+import okhttp3.Callback;
+import okhttp3.OkHttpClient;
+import okhttp3.Request;
+import okhttp3.Response;
+import okhttp3.ResponseBody;
+
+import java.io.BufferedInputStream;
 import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.net.HttpURLConnection;
+import java.net.URL;
+import java.net.URLConnection;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.UUID;
+import java.util.concurrent.Semaphore;
+import java.util.concurrent.atomic.AtomicReference;
 
 public class Utils {
   static int videoCompressionThreshold=10;
@@ -41,8 +57,10 @@ public class Utils {
       }
       @Override
       public void onFinish(boolean result) {
+        String fileUrl="file://"+destinationPath;
         //convert finish,result(true is success,false is fail)
-        promise.resolve("file://"+destinationPath);
+        promise.resolve(fileUrl);
+        MediaCache.removeCompletedImagePath(fileUrl);
       }
 
       @Override
@@ -97,7 +115,25 @@ public class Utils {
       .emit(eventName, params);
   }
 
-  public static String getRealPath(String fileUrl,ReactApplicationContext reactContext){
+  public static int getFileSizeFromURL(String urlString) {
+    URL url;
+    HttpURLConnection conn = null;
+    try {
+      url = new URL(urlString);
+      conn = (HttpURLConnection) url.openConnection();
+      conn.setRequestMethod("HEAD");
+      conn.getInputStream();
+      return conn.getContentLength();
+    } catch (IOException e) {
+      throw new RuntimeException(e);
+    } finally {
+      if (conn != null) {
+        conn.disconnect();
+      }
+    }
+  }
+
+  public static String getRealPath(String fileUrl,ReactApplicationContext reactContext, String... args){
     if(fileUrl.startsWith("content://"))
     {
       try {
@@ -105,9 +141,132 @@ public class Utils {
         fileUrl= RealPathUtil.getRealPath(reactContext,uri);
       }
       catch (Exception ex) {
-        Log.d(TAG, " Please see this issue: https://github.com/Shobbak/react-native-compressor/issues/25");
+        Log.d(TAG, " Please see this issue: https://github.com/numandev1/react-native-compressor/issues/25");
       }
     }
+    else if(fileUrl.startsWith("http://")||fileUrl.startsWith("https://"))
+    {
+      String uuid = (args.length > 0) ? args[0] : "";
+      fileUrl=downloadMediaWithProgress(fileUrl,reactContext, uuid);
+      Log.d(TAG, "getRealPath: "+fileUrl);
+    }
+
     return fileUrl;
   }
+
+  public static String downloadMediaWithProgress(String mediaUrl, ReactApplicationContext reactContext, String uuid) {
+    downloadCompression[0]=0;
+    OkHttpClient client = new OkHttpClient();
+
+    Request request = new Request.Builder()
+      .url(mediaUrl)
+      .build();
+
+    final Semaphore semaphore = new Semaphore(0); // Semaphore to wait for the download to complete
+    final AtomicReference<String> filePathRef = new AtomicReference<>(null); // To store the file path
+
+    // Perform the request asynchronously
+    client.newCall(request).enqueue(new Callback() {
+      @Override
+      public void onResponse(Call call, Response response) throws IOException {
+        if (response.isSuccessful()) {
+          ResponseBody responseBody = response.body();
+          if (responseBody != null) {
+            String fileExtension = "unknown"; // Default extension
+
+            // Detect the file extension based on the Content-Type header
+            String contentType = response.header("Content-Type");
+            if (contentType != null) {
+              if (contentType.equals("image/jpeg")) {
+                fileExtension = "jpg";
+              } else if (contentType.equals("image/png")) {
+                fileExtension = "png";
+              } else if (contentType.equals("video/mp4")) {
+                fileExtension = "mp4";
+              }
+            }
+
+            File cacheDir = reactContext.getCacheDir();
+            String randomFileName = UUID.randomUUID().toString() + "." + fileExtension;
+            File mediaFile = new File(cacheDir, randomFileName);
+
+            try (FileOutputStream fos = new FileOutputStream(mediaFile)) {
+              BufferedInputStream inputStream = new BufferedInputStream(responseBody.byteStream());
+              byte[] buffer = new byte[4096];
+              int bytesRead;
+              long totalBytesRead = 0;
+              long totalBytes = responseBody.contentLength();
+
+              if (totalBytes <= 0) {
+                totalBytes = 31457280;
+              }
+
+              Log.d(TAG, totalBytesRead+" totalBytesRead "+totalBytes);
+              Log.d(TAG, response.toString()+" responseBody "+responseBody.toString());
+              while ((bytesRead = inputStream.read(buffer)) != -1) {
+                fos.write(buffer, 0, bytesRead);
+                totalBytesRead += bytesRead;
+                double progressRatio = (double) totalBytesRead / totalBytes;
+                int progress = (int) (progressRatio * 100);
+                sendProgressUpdate(progress, uuid, reactContext);
+              }
+              fos.flush();
+              String filePath="file://" + mediaFile.getAbsolutePath();
+              MediaCache.addCompletedImagePath(filePath);
+              filePathRef.set(filePath); // Set the file path
+            } catch (IOException e) {
+              e.printStackTrace();
+              sendErrorResult(e.getMessage(), uuid, reactContext);
+            } finally {
+              semaphore.release(); // Release the semaphore when download is complete
+            }
+          }
+        } else {
+          sendErrorResult("Failed to download media: " + response.message(), uuid, reactContext);
+          semaphore.release(); // Release the semaphore in case of error
+        }
+      }
+
+      @Override
+      public void onFailure(Call call, IOException e) {
+        e.printStackTrace();
+        sendErrorResult(e.getMessage(), uuid, reactContext);
+        semaphore.release(); // Release the semaphore in case of failure
+      }
+    });
+
+    try {
+      semaphore.acquire(); // Wait for the download to complete
+    } catch (InterruptedException e) {
+      e.printStackTrace();
+    }
+
+    return filePathRef.get(); // Return the file path
+  }
+  static final int[] downloadCompression = {0};
+  private static void sendProgressUpdate(int progress, String uuid, ReactApplicationContext reactContext) {
+    int roundProgress=Math.round(progress);
+    if(roundProgress%videoCompressionThreshold==0&&roundProgress> downloadCompression[0]) {
+      WritableMap params = Arguments.createMap();
+      WritableMap data = Arguments.createMap();
+      params.putString("uuid", uuid);
+      data.putDouble("progress", progress / 100.0);
+      params.putMap("data", data);
+      sendEvent(reactContext, "downloadProgress", params);
+      Log.d(TAG, "downloadProgress: " + (progress / 100.0));
+      downloadCompression[0] =roundProgress;
+    }
+  }
+
+  private static void sendErrorResult(String error, String uuid, ReactApplicationContext reactContext) {
+    WritableMap params = Arguments.createMap();
+    WritableMap data = Arguments.createMap();
+    params.putString("uuid", uuid);
+    params.putString("error", error);
+    params.putMap("data", data);
+    Log.d(TAG, "videoDownloadError: "+error);
+    sendEvent(reactContext, "videoDownloadError", params);
+  }
+
+
 }

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

@@ -96,11 +96,11 @@ public class VideoCompressorHelper {
     auto, manual
   }
 
-  public VideoCompressorHelper.CompressionMethod compressionMethod = VideoCompressorHelper.CompressionMethod.manual;
+  public VideoCompressorHelper.CompressionMethod compressionMethod = VideoCompressorHelper.CompressionMethod.auto;
   public float bitrate = 0;
   public String uuid = "";
   public float maxSize = 640.0f;
-  public float minimumFileSizeForCompress = 16.0f;
+  public float minimumFileSizeForCompress = 0.0f;
 
   public static VideoCompressorHelper fromMap(ReadableMap map) {
     final VideoCompressorHelper options = new VideoCompressorHelper();
@@ -116,12 +116,15 @@ public class VideoCompressorHelper {
         case "maxSize":
           options.maxSize = (float) map.getDouble(key);
           break;
-          case "uuid":
+        case "uuid":
           options.uuid = map.getString(key);
           break;
         case "minimumFileSizeForCompress":
           options.minimumFileSizeForCompress =(float) map.getDouble(key);
           break;
+        case "bitrate":
+          options.bitrate = (float) map.getDouble(key);
+          break;
 
       }
     }
@@ -149,7 +152,7 @@ public class VideoCompressorHelper {
       int bitrate=Integer.parseInt(metaRetriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_BITRATE));
 
       boolean isPortrait = height > width;
-      int maxSize = 1920;
+      int maxSize = (int) options.maxSize;
       if(isPortrait && height > maxSize){
         width = (int) (((float)maxSize/height)*width);
         height = maxSize;

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

@@ -8,13 +8,10 @@ import androidx.annotation.Nullable;
 
 import com.facebook.react.bridge.Promise;
 import com.facebook.react.bridge.ReactApplicationContext;
-import com.facebook.react.bridge.ReactContext;
-import com.facebook.react.bridge.ReactContextBaseJavaModule;
 import com.facebook.react.bridge.ReactMethod;
 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.MediaCache;
+import com.reactnativecompressor.VideoCompressorSpec;
 import com.reactnativecompressor.Utils.RealPathUtil;
 
 import static com.reactnativecompressor.Utils.Utils.getRealPath;
@@ -23,14 +20,15 @@ import static com.reactnativecompressor.Video.VideoCompressorHelper.video_deacti
 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 class VideoModule extends VideoCompressorSpec {
   public static final String NAME = "VideoCompressor";
   private static final String TAG = "react-native-compessor";
   private final ReactApplicationContext reactContext;
-  public VideoModule(ReactApplicationContext reactContext) {
-    super(reactContext);
-    this.reactContext = reactContext;
+
+  public VideoModule(ReactApplicationContext context) {
+    super(context);
+    this.reactContext = context;
   }
 
   @NonNull
@@ -39,14 +37,6 @@ public class  VideoModule extends ReactContextBaseJavaModule {
     return NAME;
   }
 
-  private void sendEvent(ReactContext reactContext,
-                         String eventName,
-                         @Nullable WritableMap params) {
-    reactContext
-      .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
-      .emit(eventName, params);
-  }
-
   //Video
   @ReactMethod
   public void compress(
@@ -54,7 +44,8 @@ public class  VideoModule extends ReactContextBaseJavaModule {
     ReadableMap optionMap,
     Promise promise) {
     final VideoCompressorHelper options = VideoCompressorHelper.fromMap(optionMap);
-    fileUrl=getRealPath(fileUrl,reactContext);
+
+    fileUrl=getRealPath(fileUrl,reactContext,options.uuid);
 
     if(options.compressionMethod==VideoCompressorHelper.CompressionMethod.auto)
     {
@@ -64,8 +55,6 @@ public class  VideoModule extends ReactContextBaseJavaModule {
     {
       VideoCompressorHelper.VideoCompressManual(fileUrl,options,promise,reactContext);
     }
-
-
   }
 
   @ReactMethod
@@ -117,7 +106,7 @@ public class  VideoModule extends ReactContextBaseJavaModule {
   }
 
   @ReactMethod
-  public void removeListeners(Integer count) {
+  public void removeListeners(double count) {
     // Keep: Required for RN built in Event Emitter Calls.
   }
 }

package/android/src/newarch/CompressorSpec.java

@@ -0,0 +1,9 @@
+package com.reactnativecompressor;
+
+import com.facebook.react.bridge.ReactApplicationContext;
+
+abstract class CompressorSpec extends NativeCompressorSpec {
+  CompressorSpec(ReactApplicationContext context) {
+    super(context);
+  }
+}

package/android/src/newarch/VideoCompressorSpec.java

@@ -0,0 +1,9 @@
+package com.reactnativecompressor;
+
+import com.facebook.react.bridge.ReactApplicationContext;
+
+public abstract class VideoCompressorSpec extends NativeVideoCompressorSpec {
+  protected VideoCompressorSpec(ReactApplicationContext context) {
+    super(context);
+  }
+}

package/android/src/oldarch/CompressorSpec.java

@@ -0,0 +1,34 @@
+package com.reactnativecompressor;
+
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.ReadableMap;
+
+abstract class CompressorSpec extends ReactContextBaseJavaModule {
+  CompressorSpec(ReactApplicationContext context) {
+    super(context);
+  }
+
+  public abstract void image_compress(
+      String imagePath,
+      ReadableMap optionMap,
+      Promise promise);
+
+  public abstract void compress_audio(
+      String fileUrl,
+      ReadableMap optionMap,
+      Promise promise);
+
+  public abstract void generateFilePath(String extension, Promise promise);
+
+  public abstract void getRealPath(String path, String type, Promise promise);
+
+  public abstract void getVideoMetaData(String filePath, Promise promise);
+
+  public abstract void getFileSize(String filePath, Promise promise);
+
+  public abstract void addListener(String eventName);
+
+  public abstract void removeListeners(double count);
+}

package/android/src/oldarch/VideoCompressorSpec.java

@@ -0,0 +1,26 @@
+package com.reactnativecompressor;
+
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.ReadableMap;
+
+public abstract class VideoCompressorSpec extends ReactContextBaseJavaModule {
+  public VideoCompressorSpec(ReactApplicationContext context) {
+    super(context);
+  }
+
+  public abstract void compress(String fileUrl, ReadableMap optionMap, Promise promise);
+
+  public abstract void cancelCompression(String uuid);
+
+  public abstract void upload(String fileUrl, ReadableMap options, Promise promise);
+
+  public abstract void activateBackgroundTask(ReadableMap options, Promise promise);
+
+  public abstract void deactivateBackgroundTask(ReadableMap options, Promise promise);
+
+  public abstract void addListener(String eventName);
+
+  public abstract void removeListeners(double count);
+}

package/ios/Compressor-Bridging-Header.h

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

package/ios/Compressor.h

@@ -1,5 +1,13 @@
+#import <React/RCTEventEmitter.h>
+
+#ifdef RCT_NEW_ARCH_ENABLED
+#import "RNCompressorSpec.h"
+
+@interface Compressor : RCTEventEmitter <NativeCompressorSpec>
+#else
 #import <React/RCTBridgeModule.h>
 
-@interface Compressor : NSObject <RCTBridgeModule>
+@interface Compressor : RCTEventEmitter <RCTBridgeModule>
+#endif
 
 @end