react-native-compressor 1.7.0 → 1.7.2

package/README.md

@@ -5,18 +5,21 @@
 
 <div align="center">
 
-[![GitHub Repo stars](https://img.shields.io/static/v1?style=for-the-badge&message=Discord&color=5865F2&logo=Discord&logoColor=FFFFFF&label=)](https://discord.gg/dtYzk8sp)
+[![GitHub Repo stars](https://img.shields.io/static/v1?style=for-the-badge&message=Discord&color=5865F2&logo=Discord&logoColor=FFFFFF&label=)](https://discord.gg/6Wx8Em8KAN)
 [![GitHub Repo stars](https://img.shields.io/github/stars/numandev1/react-native-compressor?style=for-the-badge&logo=github)](https://github.com/numandev1/react-native-compressor/stargazers)
 [![GitHub Repo stars](https://img.shields.io/npm/v/react-native-compressor?style=for-the-badge&message=npm&&color=CB3837&logo=npm&logoColor=FFFFFF&label=)](https://www.npmjs.com/package/react-native-compressor)
 ![npm](https://img.shields.io/static/v1?style=for-the-badge&message=TypeScript&color=3178C6&logo=TypeScript&logoColor=FFFFFF&label=)
 ![npm](https://img.shields.io/npm/dt/react-native-compressor?style=for-the-badge)
+[![GitHub Repo stars](https://img.shields.io/badge/PRs-welcome-brightgreen.svg?style=for-the-badge)](http://makeapullrequest.com)
 
 </div>
 
-**REACT-NATIVE-COMPRESSOR** is a react-native package, which help us to Compress `Image`, `Video`, and `Audio` same like **Whatsapp** without knowing compression `algorithm`
+**REACT-NATIVE-COMPRESSOR** is a react-native package, which helps us to Compress `Image`, `Video`, and `Audio` before uploading, same like **Whatsapp** without knowing the compression `algorithm`
 
 <div align="center">
-<img height="60" src="/media/whatsapp_logo.png">
+<img height="90" src="/media/whatsapp_logo.png"/>
+&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
+<img height="90" src="/media/compress_media.png"/>
 <h2 align="center">🗜️Compress Image, Video, and Audio same like Whatsapp</h2>
 </div>
 
@@ -81,8 +84,8 @@ yarn add react-native-compressor
 ```
 
 ### [New Architecture (Turbo Module)](https://reactnative.dev/docs/new-architecture-intro) Supported
-you can give feedback on [Discord channel](https://discord.gg/dtYzk8sp)
 
+you can give feedback on [Discord channel](https://discord.gg/dtYzk8sp)
 
 ### Managed Expo
 
@@ -158,8 +161,12 @@ react-native link react-native-compressor
 ```js
 import { Image } from 'react-native-compressor';
 
-const result = await Image.compress('file://path_of_file/image.jpg', {
-  compressionMethod: 'auto',
+const result = await Image.compress('file://path_of_file/image.jpg');
+// OR
+const result = await Image.compress('https://path_of_file/image.jpg', {
+  downloadProgress: (progress) => {
+    console.log('downloadProgress: ', progress);
+  },
 });
 ```
 
@@ -171,6 +178,7 @@ const result = await Image.compress('file://path_of_file/image.jpg', {
 import { Image } from 'react-native-compressor';
 
 const result = await Image.compress('file://path_of_file/image.jpg', {
+  compressionMethod: 'manual',
   maxWidth: 1000,
   quality: 0.8,
 });
@@ -185,15 +193,23 @@ import { Video } from 'react-native-compressor';
 
 const result = await Video.compress(
   'file://path_of_file/BigBuckBunny.mp4',
+  {},
+  (progress) => {
+    console.log('Compression Progress: ', progress);
+  }
+);
+
+//OR
+
+const result = await Video.compress(
+  'https://example.com/video.mp4',
   {
-    compressionMethod: 'auto',
+    downloadProgress: (progress) => {
+      console.log('downloadProgress: ', progress);
+    },
   },
   (progress) => {
-    if (backgroundMode) {
-      console.log('Compression Progress: ', progress);
-    } else {
-      setCompressingProgress(progress);
-    }
+    console.log('Compression Progress: ', progress);
   }
 );
 ```
@@ -207,13 +223,11 @@ import { Video } from 'react-native-compressor';
 
 const result = await Video.compress(
   'file://path_of_file/BigBuckBunny.mp4',
-  {},
+  {
+    compressionMethod: 'manual',
+  },
   (progress) => {
-    if (backgroundMode) {
-      console.log('Compression Progress: ', progress);
-    } else {
-      setCompressingProgress(progress);
-    }
+    console.log('Compression Progress: ', progress);
   }
 );
 ```
@@ -286,10 +300,14 @@ const uploadResult = await backgroundUpload(
 
 ### CompressorOptions
 
-- ###### `compressionMethod: compressionMethod` (default: "manual")
+- ###### `compressionMethod: compressionMethod` (default: "auto")
 
   if you want to compress images like **whatsapp** then make this prop `auto`. Can be either `manual` or `auto`, defines the Compression Method.
 
+- ##### `downloadProgress?: (progress: number) => void;`
+
+  it is callback, only trigger when we pass image url from server
+
 - ###### `maxWidth: number` (default: 1280)
 
   The maximum width boundary used as the main boundary in resizing a landscape image.
@@ -326,11 +344,15 @@ const uploadResult = await backgroundUpload(
 
   if you want to compress videos like **whatsapp** then make this prop `auto`. Can be either `manual` or `auto`, defines the Compression Method.
 
+- ##### `downloadProgress?: (progress: number) => void;`
+
+  it is callback, only trigger when we pass image url from server
+
 - ###### `maxSize: number` (default: 640)
 
   The maximum size can be height in case of portrait video or can be width in case of landscape video.
 
-- ###### `bitrate: string`
+- ###### `bitrate: number`
 
   bitrate of video which reduce or increase video size. if compressionMethod will auto then this prop will not work
 

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

@@ -6,17 +6,15 @@ import com.facebook.react.bridge.Promise;
 import com.facebook.react.bridge.ReactApplicationContext;
 import com.facebook.react.bridge.ReactMethod;
 
-import androidx.annotation.NonNull;
-import androidx.annotation.Nullable;
 import androidx.annotation.RequiresApi;
 
 import com.facebook.react.bridge.Arguments;
 import com.facebook.react.bridge.ReactContext;
 import com.facebook.react.bridge.ReadableMap;
 import com.facebook.react.bridge.WritableMap;
-import com.facebook.react.modules.core.DeviceEventManagerModule;
 import com.reactnativecompressor.Image.ImageCompressor;
 import com.reactnativecompressor.Image.utils.ImageCompressorOptions;
+import com.reactnativecompressor.Utils.MediaCache;
 import com.reactnativecompressor.Utils.Utils;
 import com.reactnativecompressor.Video.VideoCompressorHelper;
 import com.reactnativecompressor.CompressorSpec;
@@ -40,7 +38,7 @@ public class CompressorModule extends CompressorSpec {
   public static final String NAME = "Compressor";
   private final ReactApplicationContext reactContext;
 
-  CompressorModule(ReactApplicationContext context) {
+  public CompressorModule(ReactApplicationContext context) {
     super(context);
     this.reactContext = context;
   }
@@ -51,15 +49,6 @@ public class CompressorModule extends CompressorSpec {
     return NAME;
   }
 
-
-  private void sendEvent(ReactContext reactContext,
-                         String eventName,
-                         @Nullable WritableMap params) {
-    reactContext
-      .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
-      .emit(eventName, params);
-  }
-
   //Image
   @ReactMethod
   public void image_compress(
@@ -67,8 +56,9 @@ public class CompressorModule extends CompressorSpec {
     ReadableMap optionMap,
     Promise promise) {
     try {
-      imagePath=Utils.getRealPath(imagePath,reactContext);
       final ImageCompressorOptions options = ImageCompressorOptions.fromMap(optionMap);
+      imagePath=Utils.getRealPath(imagePath,reactContext,options.uuid);
+
 
       if(options.compressionMethod==ImageCompressorOptions.CompressionMethod.auto)
       {
@@ -80,6 +70,7 @@ public class CompressorModule extends CompressorSpec {
         String returnableResult=ImageCompressor.manualCompressImage(imagePath,options,reactContext);
         promise.resolve(returnableResult);
       }
+      MediaCache.removeCompletedImagePath(imagePath);
     } catch (Exception ex) {
       promise.reject(ex);
     }
@@ -163,17 +154,34 @@ public class CompressorModule extends CompressorSpec {
   @ReactMethod
   public void getFileSize(String filePath, Promise promise)
   {
-    filePath=Utils.getRealPath(filePath,reactContext);
-    Uri uri= Uri.parse(filePath);
-    ContentResolver contentResolver = reactContext.getContentResolver();
-    long fileSize = getLength(uri, contentResolver);
-    if (fileSize >= 0) {
-      promise.resolve(String.valueOf(fileSize));
-    } else {
-      promise.resolve("");
+    if(filePath.startsWith("http://")||filePath.startsWith("https://"))
+    {
+      promise.resolve(Utils.getFileSizeFromURL(filePath));
+    }
+    else
+    {
+      filePath=Utils.getRealPath(filePath,reactContext);
+      Uri uri= Uri.parse(filePath);
+      ContentResolver contentResolver = reactContext.getContentResolver();
+      long fileSize = getLength(uri, contentResolver);
+      if (fileSize >= 0) {
+        promise.resolve(String.valueOf(fileSize));
+      } else {
+        promise.resolve("");
+      }
     }
   }
 
+  @ReactMethod
+  public void addListener(String eventName) {
+
+  }
+
+  @ReactMethod
+  public void removeListeners(double count) {
+
+  }
+
   public static long getLength(Uri uri, ContentResolver contentResolver) {
     AssetFileDescriptor assetFileDescriptor = null;
     try {
@@ -208,4 +216,5 @@ public class CompressorModule extends CompressorSpec {
       return -1L;
     }
   }
+
 }

package/android/src/main/java/com/reactnativecompressor/Image/ImageCompressor.java

@@ -201,22 +201,7 @@ public class ImageCompressor {
       bmp.recycle();
     }
 
-    ExifInterface exif;
-    try {
-      exif = new ExifInterface(imagePath);
-      int orientation = exif.getAttributeInt(ExifInterface.TAG_ORIENTATION, 0);
-      Matrix matrix = new Matrix();
-      if (orientation == 6) {
-        matrix.postRotate(90);
-      } else if (orientation == 3) {
-        matrix.postRotate(180);
-      } else if (orientation == 8) {
-        matrix.postRotate(270);
-      }
-      scaledBitmap = Bitmap.createBitmap(scaledBitmap, 0, 0, scaledBitmap.getWidth(), scaledBitmap.getHeight(), matrix, true);
-    } catch (IOException e) {
-      e.printStackTrace();
-    }
+    scaledBitmap = correctImageOrientation(scaledBitmap, imagePath);
 
     final ByteArrayOutputStream imageDataByteArrayOutputStream = ImageCompressor.compress(scaledBitmap, compressorOptions.output, compressorOptions.quality);
     String returnableResult = ImageCompressor.encodeImage(imageDataByteArrayOutputStream,isBase64,compressorOptions.output.toString(),reactContext);
@@ -242,4 +227,31 @@ public class ImageCompressor {
 
     return inSampleSize;
   }
+
+  public static Bitmap correctImageOrientation(Bitmap bitmap, String imagePath) {
+    try {
+      ExifInterface exif = new ExifInterface(imagePath);
+      int orientation = exif.getAttributeInt(ExifInterface.TAG_ORIENTATION, ExifInterface.ORIENTATION_NORMAL);
+      Matrix matrix = new Matrix();
+
+      switch (orientation) {
+        case ExifInterface.ORIENTATION_ROTATE_90:
+          matrix.postRotate(90);
+          break;
+        case ExifInterface.ORIENTATION_ROTATE_180:
+          matrix.postRotate(180);
+          break;
+        case ExifInterface.ORIENTATION_ROTATE_270:
+          matrix.postRotate(270);
+          break;
+        default:
+          return bitmap; // No rotation needed
+      }
+
+      return Bitmap.createBitmap(bitmap, 0, 0, bitmap.getWidth(), bitmap.getHeight(), matrix, true);
+    } catch (IOException e) {
+      e.printStackTrace();
+      return bitmap; // Return original bitmap if an error occurs
+    }
+  }
 }

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;
             }
         }
 
@@ -61,5 +64,6 @@ public class ImageCompressorOptions {
     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 {
@@ -108,6 +144,129 @@ public class Utils {
         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/VideoModule.java

@@ -8,13 +8,9 @@ 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;
 
@@ -41,14 +37,6 @@ public class VideoModule extends VideoCompressorSpec {
     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(
@@ -56,7 +44,8 @@ public class VideoModule extends VideoCompressorSpec {
     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)
     {
@@ -66,8 +55,6 @@ public class VideoModule extends VideoCompressorSpec {
     {
       VideoCompressorHelper.VideoCompressManual(fileUrl,options,promise,reactContext);
     }
-
-
   }
 
   @ReactMethod

package/android/src/oldarch/CompressorSpec.java

@@ -11,18 +11,24 @@ abstract class CompressorSpec extends ReactContextBaseJavaModule {
   }
 
   public abstract void image_compress(
-    String imagePath,
-    ReadableMap optionMap,
-    Promise promise);
+      String imagePath,
+      ReadableMap optionMap,
+      Promise promise);
 
   public abstract void compress_audio(
-    String fileUrl,
-    ReadableMap optionMap,
-    Promise promise);
+      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 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/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,12 +1,13 @@
+#import <React/RCTEventEmitter.h>
 
 #ifdef RCT_NEW_ARCH_ENABLED
 #import "RNCompressorSpec.h"
 
-@interface Compressor : NSObject <NativeCompressorSpec>
+@interface Compressor : RCTEventEmitter <NativeCompressorSpec>
 #else
 #import <React/RCTBridgeModule.h>
 
-@interface Compressor : NSObject <RCTBridgeModule>
+@interface Compressor : RCTEventEmitter <RCTBridgeModule>
 #endif
 
 @end