react-native-compressor 1.6.4 → 1.7.1

package/ios/Image/ImageCompressor.m

@@ -7,8 +7,24 @@
 #import <React/RCTConvert.h>
 #import <Foundation/Foundation.h>
 #import <MobileCoreServices/MobileCoreServices.h>
+#import <React/RCTEventEmitter.h>
+#import "../Utils/Downloader.h"
+#import "react_native_compressor-Swift.h"
+#import "VideoCompressor.h"
+#import "MediaCache.h"
 
 @implementation ImageCompressor
+Compressor *sharedCompressorObject;
+id sharedVideoCompressorObject;
+
++ (void)initCompressorInstance:(Compressor*)instance {
+    sharedCompressorObject=instance;
+}
+
++ (void)initVideoCompressorInstance:(id)object {
+    sharedVideoCompressorObject=object;
+}
+
 + (CGSize) findTargetSize: (UIImage *) image maxWidth: (int) maxWidth maxHeight: (int) maxHeight {
     CGFloat width = image.size.width;
     CGFloat height = image.size.height;
@@ -293,86 +309,167 @@
         return returnablePath;
 }
 
-+(void)getAbsoluteImagePath:(NSString *)imagePath completionHandler:(void (^)(NSString *absoluteImagePath))completionHandler
+
++ (void)getFileSizeFromURL:(NSString *)urlString completion:(void (^)(NSNumber *fileSize, NSError *error))completion {
+    NSURL *url = [NSURL URLWithString:urlString];
+    NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:url];
+    [request setHTTPMethod:@"HEAD"];
+
+    NSURLSession *session = [NSURLSession sharedSession];
+    NSURLSessionDataTask *task = [session dataTaskWithRequest:request completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
+        if (error) {
+            if (completion) {
+                completion(nil, error);
+            }
+            return;
+        }
+
+        if ([response isKindOfClass:[NSHTTPURLResponse class]]) {
+            NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *)response;
+            long long contentLength = [httpResponse expectedContentLength];
+            if (completion) {
+                completion([NSNumber numberWithLongLong:contentLength], nil);
+            }
+        } else {
+            if (completion) {
+                completion(nil, [NSError errorWithDomain:@"FileDownloadError" code:-1 userInfo:@{NSLocalizedDescriptionKey: @"Invalid response."}]);
+            }
+        }
+    }];
+
+    [task resume];
+}
+
+
++ (void)sendProgressUpdate:(NSNumber*)progress uuid:(NSString *)uuid type:(NSString *)type {
+    NSMutableDictionary *params = [[NSMutableDictionary alloc] init];
+    NSMutableDictionary *data = [[NSMutableDictionary alloc] init];
+    params[@"uuid"] = uuid;
+    data[@"progress"] = progress;
+    params[@"data"] = data;
+    
+    if(type==@"image")
+    {
+        [sharedCompressorObject sendEventWithName:@"downloadProgress" body:params];
+    }
+    else
+    {
+        [sharedVideoCompressorObject sendEventWithName:@"downloadProgress" body:params];
+    }
+    
+}
+
+
++ (void)downloadFileAndSaveToCache:(NSString *)fileUrl uuid:(NSString *)uuid type:(NSString *)type completion:(void (^)(NSString *downloadedPath))completion {
+    
+    Downloader *downloader = [[Downloader alloc] init];
+    [downloader downloadFile:fileUrl downloadCompleteCallback:^(NSString *filePath) {
+        [MediaCache addCompletedImagePath:filePath];
+        NSLog(@"download completed file path: %@",filePath);
+        completion(filePath);
+    } progressCallback:^(NSNumber * progress) {
+        [self sendProgressUpdate:progress uuid:uuid type:type];
+        
+    } errorCallback:^(NSError * error) {
+        NSLog(@"error downloadFile",error);
+    }];
+}
+
++(void)getAbsoluteImagePath:(NSString *)imagePath uuid:(NSString *)uuid completionHandler:(void (^)(NSString *absoluteImagePath))completionHandler
 {
-  if (![imagePath containsString:@"ph://"]) {
-    completionHandler(imagePath);
-    return;
-  }
-  NSURL *imageURL = [NSURL URLWithString:[imagePath stringByReplacingOccurrencesOfString:@" " withString:@"%20"]];
-  CGSize size = CGSizeZero;
-  CGFloat scale = 1;
-  RCTResizeMode resizeMode = RCTResizeModeContain;
-  NSString *assetID = @"";
-  PHFetchResult *results;
-  if (!imageURL) {
-    NSString *errorText = @"Cannot load a photo library asset with no URL";
-    @throw([NSException exceptionWithName:errorText reason:errorText userInfo:nil]);
-  } else if ([imageURL.scheme caseInsensitiveCompare:@"assets-library"] == NSOrderedSame) {
-    assetID = [imageURL absoluteString];
-    results = [PHAsset fetchAssetsWithALAssetURLs:@[imageURL] options:nil];
-  } else {
-    assetID = [imageURL.absoluteString substringFromIndex:@"ph://".length];
-    results = [PHAsset fetchAssetsWithLocalIdentifiers:@[assetID] options:nil];
-  }
-  if (results.count == 0) {
-    NSString *errorText = [NSString stringWithFormat:@"Failed to fetch PHAsset with local identifier %@ with no error message.", assetID];
-   @throw([NSException exceptionWithName:errorText reason:errorText userInfo:nil]);
-  }
-  PHAsset *asset = [results firstObject]; // <-- WE GOT THE ASSET
-  PHImageRequestOptions *imageOptions = [PHImageRequestOptions new];
-  imageOptions.networkAccessAllowed = YES;
-  imageOptions.deliveryMode = PHImageRequestOptionsDeliveryModeHighQualityFormat;
-
-  BOOL useMaximumSize = CGSizeEqualToSize(size, CGSizeZero);
-  CGSize targetSize;
-  if (useMaximumSize) {
-    targetSize = PHImageManagerMaximumSize;
-    imageOptions.resizeMode = PHImageRequestOptionsResizeModeNone;
-  } else {
-    targetSize = CGSizeApplyAffineTransform(size, CGAffineTransformMakeScale(scale, scale));
-    imageOptions.resizeMode = PHImageRequestOptionsResizeModeFast;
-  }
-
-  PHImageContentMode contentMode = PHImageContentModeAspectFill;
-  if (resizeMode == RCTResizeModeContain) {
-    contentMode = PHImageContentModeAspectFit;
-  }
-  [[PHImageManager defaultManager] requestImageForAsset:asset
-                                             targetSize:targetSize
-                                            contentMode:contentMode
-                                                options:imageOptions
-                                          resultHandler:^(UIImage *result, NSDictionary<NSString *, id> *info) {
-    // WE GOT THE IMAGE
-    if (result) {
-      UIImage *image = result;
-      NSString *imageName = [assetID stringByReplacingOccurrencesOfString:@"/" withString:@"_"];
-      NSString *imagePath = [self saveImageIntoCache:image withName:imageName];
-    completionHandler(imagePath);
+    if([imagePath hasPrefix:@"http://"]||[imagePath hasPrefix:@"https://"])
+    {
+        [ImageCompressor downloadFileAndSaveToCache:imagePath uuid:uuid type:@"image" completion:^(NSString *downloadedPath) {
+            completionHandler(downloadedPath); // Pass the downloaded path to the completionHandler
+        }];
+        return;
+
+    }
+    else if (![imagePath containsString:@"ph://"]) {
+        completionHandler(imagePath);
+        return;
+    }
+    NSURL *imageURL = [NSURL URLWithString:[imagePath stringByReplacingOccurrencesOfString:@" " withString:@"%20"]];
+    CGSize size = CGSizeZero;
+    CGFloat scale = 1;
+    RCTResizeMode resizeMode = RCTResizeModeContain;
+    NSString *assetID = @"";
+    PHFetchResult *results;
+    if (!imageURL) {
+        NSString *errorText = @"Cannot load a photo library asset with no URL";
+        @throw([NSException exceptionWithName:errorText reason:errorText userInfo:nil]);
+    } else if ([imageURL.scheme caseInsensitiveCompare:@"assets-library"] == NSOrderedSame) {
+        assetID = [imageURL absoluteString];
+        results = [PHAsset fetchAssetsWithALAssetURLs:@[imageURL] options:nil];
     } else {
-        @throw([NSException exceptionWithName:@"image not found" reason:@"image not found" userInfo:nil]);
+        assetID = [imageURL.absoluteString substringFromIndex:@"ph://".length];
+        results = [PHAsset fetchAssetsWithLocalIdentifiers:@[assetID] options:nil];
+    }
+    if (results.count == 0) {
+        NSString *errorText = [NSString stringWithFormat:@"Failed to fetch PHAsset with local identifier %@ with no error message.", assetID];
+        @throw([NSException exceptionWithName:errorText reason:errorText userInfo:nil]);
     }
-  }];
+    PHAsset *asset = [results firstObject]; // <-- WE GOT THE ASSET
+    PHImageRequestOptions *imageOptions = [PHImageRequestOptions new];
+    imageOptions.networkAccessAllowed = YES;
+    imageOptions.deliveryMode = PHImageRequestOptionsDeliveryModeHighQualityFormat;
+    
+    BOOL useMaximumSize = CGSizeEqualToSize(size, CGSizeZero);
+    CGSize targetSize;
+    if (useMaximumSize) {
+        targetSize = PHImageManagerMaximumSize;
+        imageOptions.resizeMode = PHImageRequestOptionsResizeModeNone;
+    } else {
+        targetSize = CGSizeApplyAffineTransform(size, CGAffineTransformMakeScale(scale, scale));
+        imageOptions.resizeMode = PHImageRequestOptionsResizeModeFast;
+    }
+    
+    PHImageContentMode contentMode = PHImageContentModeAspectFill;
+    if (resizeMode == RCTResizeModeContain) {
+        contentMode = PHImageContentModeAspectFit;
+    }
+    [[PHImageManager defaultManager] requestImageForAsset:asset
+                                               targetSize:targetSize
+                                              contentMode:contentMode
+                                                  options:imageOptions
+                                            resultHandler:^(UIImage *result, NSDictionary<NSString *, id> *info) {
+        // WE GOT THE IMAGE
+        if (result) {
+            UIImage *image = result;
+            NSString *imageName = [assetID stringByReplacingOccurrencesOfString:@"/" withString:@"_"];
+            NSString *imagePath = [self saveImageIntoCache:image withName:imageName];
+            completionHandler(imagePath);
+        } else {
+            @throw([NSException exceptionWithName:@"image not found" reason:@"image not found" userInfo:nil]);
+        }
+    }];
 }
 
 +(NSString*) saveImageIntoCache:(UIImage *)image withName:(NSString *)name {
-  NSData *imageData = UIImageJPEGRepresentation(image, 1);
+    NSData *imageData = UIImageJPEGRepresentation(image, 1);
     NSString *path =[self generateCacheFilePath:@"jpg"];
-  [[NSFileManager defaultManager] createFileAtPath:path contents:imageData attributes:NULL];
-  return path;
+    [[NSFileManager defaultManager] createFileAtPath:path contents:imageData attributes:NULL];
+    return path;
 }
 
 /// for video
-    
-+(void)getAbsoluteVideoPath:(NSString *)videoPath completionHandler:(void (^)(NSString *absoluteImagePath))completionHandler
+
++(void)getAbsoluteVideoPath:(NSString *)videoPath uuid:(NSString *)uuid completionHandler:(void (^)(NSString *absoluteImagePath))completionHandler
 {
+    if([videoPath hasPrefix:@"http://"]||[videoPath hasPrefix:@"https://"])
+    {
+        [ImageCompressor downloadFileAndSaveToCache:videoPath uuid:uuid type:@"video" completion:^(NSString *downloadedPath) {
+            completionHandler(downloadedPath); // Pass the downloaded path to the completionHandler
+        }];
+        return;
 
-    if (![videoPath containsString:@"ph://"]) {
-      completionHandler(videoPath);
-      return;
+    }
+    else if (![videoPath containsString:@"ph://"]) {
+        completionHandler(videoPath);
+        return;
     }
     NSString *assetId =[videoPath stringByReplacingOccurrencesOfString:@"ph://"
-                                                      withString:@""];
+                                                            withString:@""];
     AVFileType outputFileType = AVFileTypeMPEG4;
     NSString *pressetType = AVAssetExportPresetPassthrough;
     
@@ -390,7 +487,7 @@
     // Getting information from the asset
     NSString *mimeType = (NSString *)CFBridgingRelease(UTTypeCopyPreferredTagWithClass((__bridge CFStringRef _Nonnull)(outputFileType), kUTTagClassMIMEType));
     CFStringRef uti = UTTypeCreatePreferredIdentifierForTag(kUTTagClassMIMEType, (__bridge CFStringRef _Nonnull)(mimeType), NULL);
-     NSString *extension = (NSString *)CFBridgingRelease(UTTypeCopyPreferredTagWithClass(uti, kUTTagClassFilenameExtension));
+    NSString *extension = (NSString *)CFBridgingRelease(UTTypeCopyPreferredTagWithClass(uti, kUTTagClassFilenameExtension));
     
     // Creating output url and temp file name
     NSString *path =[self generateCacheFilePath:extension];

package/ios/Image/ImageCompressorOptions.h

@@ -23,5 +23,6 @@ typedef NS_ENUM(long, ReturnableOutputType) { rbase64,
 @property(nonatomic, assign) enum OutputType output;
 @property(nonatomic, assign) enum InputType input;
 @property(nonatomic, assign) enum ReturnableOutputType returnableOutputType;
+@property(nonatomic, assign) NSString* uuid;
 
 @end

package/ios/Image/ImageCompressorOptions.m

@@ -28,7 +28,9 @@
             [options parseOutput: value];
         } else if ([key isEqual:@"returnableOutputType"]) {
             [options parseReturnableOutput: value];
-        }
+        }else if ([key isEqual:@"uuid"]) {
+           options.uuid=value;
+       }
     }
     
     return options;
@@ -56,6 +58,7 @@
         self.input = uri;
         self.output = jpg;
         self.returnableOutputType = uri;
+        self.uuid = uuid;
     }
     
     return self;
@@ -68,6 +71,7 @@
 @synthesize input;
 @synthesize output;
 @synthesize returnableOutputType;
+@synthesize uuid;
 
 - (void) parseInput:(NSString*)input {
     NSDictionary *inputTranslations = @{ @"base64": @(base64), @"uri": @(uri) };

package/ios/Utils/Downloader.h

@@ -0,0 +1,16 @@
+#import <Foundation/Foundation.h>
+
+typedef void (^DownloadCompleteCallback)(NSString *filePath);
+typedef void (^ErrorCallback)(NSError*);
+typedef void (^ProgressCallback)(NSNumber*);
+
+@interface Downloader : NSObject <NSURLSessionDelegate, NSURLSessionDownloadDelegate>
+
+@property (nonatomic, copy) ProgressCallback globalProgressCallback;
+@property (nonatomic, copy) DownloadCompleteCallback globalDownloadCompleteCallback;
+@property (nonatomic, copy) ErrorCallback globalErrorCallback;
+
+- (NSString *)downloadFile:(NSString *)fromUrl downloadCompleteCallback:(DownloadCompleteCallback)downloadCompleteCallback progressCallback:(ProgressCallback)progressCallback errorCallback:(ErrorCallback)errorCallback;
+- (NSString *)generateCacheFilePath:(NSString *)extension;
+
+@end

package/ios/Utils/Downloader.m

@@ -0,0 +1,150 @@
+#import "Downloader.h"
+
+@implementation Downloader
+
+NSURLSession* _session;
+NSURLSessionDownloadTask* _task;
+NSNumber* _statusCode;
+NSTimeInterval _lastProgressEmitTimestamp;
+NSNumber* _lastProgressValue;
+NSNumber* _contentLength;
+NSNumber* _bytesWritten;
+NSData* _resumeData;
+NSString* _toFile;
+
+
+ProgressCallback globalProgressCallback;
+DownloadCompleteCallback globalDownloadCompleteCallback;
+ErrorCallback globalErrorCallback;
+
+NSFileHandle* _fileHandle;
+
+- (NSString *)generateCacheFilePath:(NSString *)extension{
+    NSUUID *uuid = [NSUUID UUID];
+    NSString *imageNameWihtoutExtension = [uuid UUIDString];
+    NSString *imageName=[imageNameWihtoutExtension stringByAppendingPathExtension:extension];
+    NSString *filePath =
+        [NSTemporaryDirectory() stringByAppendingPathComponent:imageName];
+    return filePath;
+}
+
+- (NSString *)downloadFile:(NSString *)fromUrl downloadCompleteCallback:(DownloadCompleteCallback)downloadCompleteCallback progressCallback:(ProgressCallback)progressCallback errorCallback:(ErrorCallback)errorCallback
+{
+    NSString *uuid = nil;
+
+    Downloader *downloader = [[Downloader alloc] init];
+    globalProgressCallback = progressCallback;
+    globalDownloadCompleteCallback = downloadCompleteCallback;
+    globalErrorCallback = errorCallback;
+
+  _lastProgressEmitTimestamp = 0;
+  _bytesWritten = 0;
+
+    NSURL* url = [NSURL URLWithString:fromUrl];
+    NSString *fileExtension = [fromUrl pathExtension];
+    
+    NSString *toFile =[self generateCacheFilePath:fileExtension];
+    _toFile=toFile;
+
+  if ([[NSFileManager defaultManager] fileExistsAtPath:toFile]) {
+    _fileHandle = [NSFileHandle fileHandleForWritingAtPath:toFile];
+
+    if (!_fileHandle) {
+      NSError* error = [NSError errorWithDomain:@"Downloader" code:NSURLErrorFileDoesNotExist
+                                userInfo:@{NSLocalizedDescriptionKey: [NSString stringWithFormat: @"Failed to write target file at path: %@", toFile]}];
+
+        globalErrorCallback(error);
+      return nil;
+    } else {
+      [_fileHandle closeFile];
+    }
+  }
+
+  NSURLSessionConfiguration *config;
+
+  config = [NSURLSessionConfiguration defaultSessionConfiguration];
+
+  _session = [NSURLSession sessionWithConfiguration:config delegate:downloader delegateQueue:nil];
+  _task = [_session downloadTaskWithURL:url];
+  [_task resume];
+
+    return uuid;
+}
+
+- (void)URLSession:(NSURLSession *)session downloadTask:(NSURLSessionDownloadTask *)downloadTask didWriteData:(int64_t)bytesWritten totalBytesWritten:(int64_t)totalBytesWritten totalBytesExpectedToWrite:(int64_t)totalBytesExpectedToWrite
+{
+  NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *)downloadTask.response;
+ 
+    _statusCode = [NSNumber numberWithLong:httpResponse.statusCode];
+    _contentLength = [NSNumber numberWithLong:httpResponse.expectedContentLength];
+
+    if ([_statusCode isEqualToNumber:[NSNumber numberWithInt:200]]) {
+
+    _bytesWritten = @(totalBytesWritten);
+
+  
+      double doubleBytesWritten = (double)[_bytesWritten longValue];
+      double doubleContentLength = (double)[_contentLength longValue];
+      double doublePercents = doubleBytesWritten / doubleContentLength * 100;
+      NSNumber* progress = [NSNumber numberWithUnsignedInt: floor(doublePercents)];
+        if ([progress unsignedIntValue] % 10 == 0) {
+            if (([progress unsignedIntValue] != [_lastProgressValue unsignedIntValue]) || ([_bytesWritten unsignedIntegerValue] == [_contentLength longValue])) {
+                _lastProgressValue = [NSNumber numberWithUnsignedInt:[progress unsignedIntValue]];
+                NSNumber *progressPercentage = @([_bytesWritten doubleValue] / [_contentLength doubleValue]);
+                return globalProgressCallback(progressPercentage);
+            }
+        }
+      
+    
+  }
+}
+
+- (void)URLSession:(NSURLSession *)session downloadTask:(NSURLSessionDownloadTask *)downloadTask didFinishDownloadingToURL:(NSURL *)location
+{
+  NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *)downloadTask.response;
+  if (!_statusCode) {
+    _statusCode = [NSNumber numberWithLong:httpResponse.statusCode];
+  }
+  NSURL *destURL = [NSURL fileURLWithPath:_toFile];
+  NSFileManager *fm = [NSFileManager defaultManager];
+  NSError *error = nil;
+  if([_statusCode integerValue] >= 200 && [_statusCode integerValue] < 300) {
+    [fm removeItemAtURL:destURL error:nil];       // Remove file at destination path, if it exists
+    [fm moveItemAtURL:location toURL:destURL error:&error];
+    // There are no guarantees about how often URLSession:downloadTask:didWriteData: will fire,
+    // so we read an authoritative number of bytes written here.
+    _bytesWritten = @([fm attributesOfItemAtPath:_toFile error:nil].fileSize);
+  }
+  if (error) {
+    NSLog(@"RNFS download: unable to move tempfile to destination. %@, %@", error, error.userInfo);
+  }
+
+  // When numerous downloads are called the sessions are not always invalidated and cleared by iOS14. 
+  // This leads to error 28 – no space left on device so we manually flush and invalidate to free up space
+  if(session != nil){
+    [session flushWithCompletionHandler:^{
+      [session finishTasksAndInvalidate];
+    }];
+  }
+    NSURL *fileURL = [NSURL fileURLWithPath:_toFile];
+  return globalDownloadCompleteCallback([fileURL absoluteString]);
+}
+
+- (void)URLSession:(NSURLSession *)session task:(NSURLSessionTask *)task didCompleteWithError:(NSError *)error
+{
+  if (error) {
+    NSLog(@"RNFS download: didCompleteWithError %@, %@", error, error.userInfo);
+    if (error.code != NSURLErrorCancelled) {
+      _resumeData = error.userInfo[NSURLSessionDownloadTaskResumeData];
+      if (_resumeData != nil) {
+       
+      } else {
+          globalErrorCallback(error);
+      }
+    }
+  }
+}
+
+
+
+@end

package/ios/Utils/MediaCache.h

@@ -0,0 +1,11 @@
+#import <Foundation/Foundation.h>
+
+@interface MediaCache : NSObject
+
++ (instancetype)sharedCache;
+
++ (void)addCompletedImagePath:(NSString *)imagePath;
++ (void)removeCompletedImagePath:(NSString *)imagePath;
++ (void)cleanupCache;
+
+@end

package/ios/Utils/MediaCache.m

@@ -0,0 +1,51 @@
+#import "MediaCache.h"
+
+@implementation MediaCache
+NSMutableArray<NSString *> *completedImagePaths;
+
++ (void)addCompletedImagePath:(NSString *)imagePath {
+    if (imagePath) {
+        [completedImagePaths addObject:imagePath];
+    }
+}
+
++ (void)removeCompletedImagePath:(NSString *)imagePath {
+    if (imagePath) {
+        [completedImagePaths removeObject:imagePath];
+        NSURL *fileURL = [NSURL URLWithString:imagePath];
+        NSString *fileSystemPath = [fileURL path];
+        
+        NSFileManager *fileManager = [NSFileManager defaultManager];
+        NSError *error = nil;
+        
+        if ([fileManager fileExistsAtPath:fileSystemPath isDirectory:nil]) {
+            [fileManager removeItemAtPath:fileSystemPath error:&error];
+        }
+        
+        if (error) {
+            NSLog(@"Error deleting image at path: %@", fileSystemPath);
+        }
+    }
+}
+
++ (void)cleanupCache {
+    NSFileManager *fileManager = [NSFileManager defaultManager];
+    NSString *cacheDirectory = [NSSearchPathForDirectoriesInDomains(NSCachesDirectory, NSUserDomainMask, YES) firstObject];
+    
+    for (NSString *imagePath in completedImagePaths) {
+        NSString *absoluteImagePath = [cacheDirectory stringByAppendingPathComponent:imagePath];
+        NSError *error = nil;
+        
+        if ([fileManager fileExistsAtPath:absoluteImagePath]) {
+            [fileManager removeItemAtPath:absoluteImagePath error:&error];
+        }
+        
+        if (error) {
+            NSLog(@"Error deleting image at path: %@", absoluteImagePath);
+        }
+    }
+    
+    [completedImagePaths removeAllObjects];
+}
+
+@end

package/ios/Video/VideoCompressor.swift

@@ -37,12 +37,17 @@ class VideoCompressor: RCTEventEmitter, URLSessionTaskDelegate {
   var uploadRejectors: [String: RCTPromiseRejectBlock] = [:]
   var compressorExports: [String: NextLevelSessionExporter] = [:]
     let videoCompressionThreshold:Int=7
-    
+
+    override init() {
+        super.init()
+        ImageCompressor.initVideoCompressorInstance(self)
+    }
 
   override static func requiresMainQueueSetup() -> Bool {
     return false
   }
 
+
   @objc(activateBackgroundTask:withResolver:withRejecter:)
   func activateBackgroundTask(options: [String: Any], resolve:@escaping RCTPromiseResolveBlock, reject:@escaping RCTPromiseRejectBlock) -> Void {
     guard backgroundTaskId == .invalid else {
@@ -173,7 +178,7 @@ func makeValidUri(filePath: String) -> String {
   }
 
   override func supportedEvents() -> [String]! {
-    return ["videoCompressProgress", "VideoCompressorProgress", "backgroundTaskExpired"]
+    return ["videoCompressProgress", "VideoCompressorProgress", "backgroundTaskExpired","downloadProgress"]
   }
 
   override func stopObserving() -> Void {
@@ -206,8 +211,10 @@ func makeValidUri(filePath: String) -> String {
   
   
   func compressVideo(url: URL, options: [String: Any], onProgress: @escaping (Float) -> Void,  onCompletion: @escaping (URL) -> Void, onFailure: @escaping (Error) -> Void){
-      ImageCompressor.getAbsoluteVideoPath(url.absoluteString) { absoluteVideoPath in
-        var minimumFileSizeForCompress:Double=16.0;
+      let uuid:String = options["uuid"] as! String
+      
+      ImageCompressor.getAbsoluteVideoPath(url.absoluteString, uuid: uuid) { absoluteVideoPath in
+        var minimumFileSizeForCompress:Double=0.0;
         let videoURL = URL(string: absoluteVideoPath!)
         let fileSize=self.getfileSize(forURL: videoURL!);
           if((options["minimumFileSizeForCompress"]) != nil)
@@ -216,11 +223,12 @@ func makeValidUri(filePath: String) -> String {
         }
         if(fileSize>minimumFileSizeForCompress)
         {
-            if(options["compressionMethod"] as! String=="auto")
+            if(options["compressionMethod"] as! String=="manual")
             {
                 self.autoCompressionHelper(url: videoURL!, options:options) { progress in
                     onProgress(progress)
                 } onCompletion: { outputURL in
+                    MediaCache.removeCompletedImagePath(absoluteVideoPath);
                     onCompletion(outputURL)
                 } onFailure: { error in
                     onFailure(error)
@@ -231,6 +239,7 @@ func makeValidUri(filePath: String) -> String {
                 self.manualCompressionHelper(url: videoURL!, options:options) { progress in
                     onProgress(progress)
                 } onCompletion: { outputURL in
+                    MediaCache.removeCompletedImagePath(absoluteVideoPath);
                     onCompletion(outputURL)
                 } onFailure: { error in
                     onFailure(error)

package/lib/commonjs/Audio/index.js

@@ -4,51 +4,50 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = void 0;
-
-var _reactNative = require("react-native");
-
+var _Main = require("../Main");
 var _utils = require("../utils");
-
-const NativeAudio = _reactNative.NativeModules.Compressor;
+const NativeAudio = _Main.Compressor;
 const Audio = {
-  compress: async (url, options = _utils.DEFAULT_COMPRESS_AUDIO_OPTIONS) => {
+  compress: async function (url) {
+    let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _utils.DEFAULT_COMPRESS_AUDIO_OPTIONS;
     try {
       const checkUrlAndOptionsResult = await (0, _utils.checkUrlAndOptions)(url, options);
-
       if (!checkUrlAndOptionsResult.isCorrect) {
         throw checkUrlAndOptionsResult.message;
       } else {
         // Get resulting output file path
+
         // Get media details
         // const mediaDetails: any = await getDetails(url).catch(() => null);
         const mediaDetails = {
           bitrate: 0
-        }; // Initialize bitrate
+        };
 
+        // Initialize bitrate
         let bitrate = _utils.DEFAULT_COMPRESS_AUDIO_OPTIONS.bitrate;
-
         if (mediaDetails && mediaDetails.bitrate) {
           // Check and return the appropriate bitrate according to quality expected
           for (let i = 0; i < _utils.AUDIO_BITRATE.length; i++) {
             // Check a particular bitrate to return its nearest lower according to quality
+            //@ts-ignore
             if (mediaDetails.bitrate > _utils.AUDIO_BITRATE[i]) {
               if (i + 2 < _utils.AUDIO_BITRATE.length) {
                 if (options.quality === 'low') bitrate = _utils.AUDIO_BITRATE[i + 2];else if (options.quality === 'medium') bitrate = _utils.AUDIO_BITRATE[i + 1];else bitrate = _utils.AUDIO_BITRATE[i];
               } else if (i + 1 < _utils.AUDIO_BITRATE.length) {
                 if (options.quality === 'low') bitrate = _utils.AUDIO_BITRATE[i + 1];else bitrate = _utils.AUDIO_BITRATE[i];
               } else bitrate = _utils.AUDIO_BITRATE[i];
-
               break;
-            } // Check if the matching bitrate is the last in the array
-
+            }
 
-            if (mediaDetails.bitrate <= _utils.AUDIO_BITRATE[_utils.AUDIO_BITRATE.length - 1]) {
+            // Check if the matching bitrate is the last in the array
+            if (
+            //@ts-ignore
+            mediaDetails.bitrate <= _utils.AUDIO_BITRATE[_utils.AUDIO_BITRATE.length - 1]) {
               bitrate = _utils.AUDIO_BITRATE[_utils.AUDIO_BITRATE.length - 1];
               break;
             }
           }
         }
-
         return NativeAudio.compress_audio(url, {
           bitrate,
           quality: options.quality