react-native-compressor 1.6.4 → 1.7.1

package/ios/Compressor.mm

@@ -0,0 +1,427 @@
+#import "Compressor.h"
+
+//Image
+#import "Image/ImageCompressor.h"
+#import "Image/ImageCompressorOptions.h"
+#import <React/RCTEventEmitter.h>
+#import <AVFoundation/AVFoundation.h>
+#import "MediaCache.h"
+
+#define AlAsset_Library_Scheme @"assets-library"
+@implementation Compressor
+
+AVAssetWriter *assetWriter=nil;
+static NSArray *metadatas;
+
+- (NSArray *)metadatas
+{
+  if (!metadatas) {
+    metadatas = @[
+      @"albumName",
+      @"artist",
+      @"comment",
+      @"copyrights",
+      @"creationDate",
+      @"date",
+      @"encodedby",
+      @"genre",
+      @"language",
+      @"location",
+      @"lastModifiedDate",
+      @"performer",
+      @"publisher",
+      @"title"
+    ];
+  }
+  return metadatas;
+}
+
+- (instancetype)init {
+    self = [super init];
+    [ImageCompressor initCompressorInstance:self];
+    return self;
+}
+
+RCT_EXPORT_MODULE()
+
++ (BOOL)requiresMainQueueSetup {
+  return NO;
+}
+
+
+//Image
+RCT_EXPORT_METHOD(
+    image_compress: (NSString*) imagePath
+    optionsDict: (NSDictionary*) optionsDict
+    resolver: (RCTPromiseResolveBlock) resolve
+    rejecter: (RCTPromiseRejectBlock) reject) {
+    [self image_compress:imagePath optionMap:optionsDict resolve:resolve reject:reject];
+}
+
+//Audio
+RCT_EXPORT_METHOD(
+    compress_audio: (NSString*) filePath
+    optionsDict: (NSDictionary*) optionsDict
+    resolver: (RCTPromiseResolveBlock) resolve
+    rejecter: (RCTPromiseRejectBlock) reject) {
+    [self compress_audio:filePath optionMap:optionsDict resolve:resolve reject:reject];
+}
+
+//general
+RCT_EXPORT_METHOD(
+    generateFilePath: (NSString*) extension
+    resolver: (RCTPromiseResolveBlock) resolve
+    rejecter: (RCTPromiseRejectBlock) reject) {
+    [self generateFilePath:extension resolve:resolve reject:reject];
+}
+
+RCT_EXPORT_METHOD(
+    getRealPath: (NSString*) path
+    type: (NSString*) type
+    resolver: (RCTPromiseResolveBlock) resolve
+    rejecter: (RCTPromiseRejectBlock) reject) {
+    [self getRealPath:path type:type resolve:resolve reject:reject];
+}
+
+//general
+    RCT_EXPORT_METHOD(
+        getFileSize: (NSString*) filePath
+        resolver: (RCTPromiseResolveBlock) resolve
+        rejecter: (RCTPromiseRejectBlock) reject) {
+        [self getFileSize:filePath resolve:resolve reject:reject];
+    }
+
+
+RCT_EXPORT_METHOD(
+    getVideoMetaData: (NSString*) filePath
+    resolver: (RCTPromiseResolveBlock) resolve
+    rejecter: (RCTPromiseRejectBlock) reject) {
+    [self getVideoMetaData:filePath resolve:resolve reject:reject];
+}
+
+- (NSArray<NSString *>*)supportedEvents {
+    return @[@"downloadProgress"];
+}
+
+- (NSString *)getAudioQualityConstant:(NSString *)quality
+{
+    NSMutableArray *audioQualityArray = [[NSMutableArray alloc]initWithObjects:@"low", @"medium", @"high", nil];
+    int index = [audioQualityArray indexOfObject:quality];
+    switch (index) {
+        case 0:
+            return AVAssetExportPresetLowQuality;
+            break;
+        case 1:
+            return AVAssetExportPresetMediumQuality;
+            break;
+        case 2:
+            return AVAssetExportPresetHighestQuality;
+            break;
+    }
+    return AVAssetExportPresetMediumQuality;
+}
+
+- (void)audo_compress_helper:(AVURLAsset *)avAsset qualityConstant:(NSString *)qualityConstant complete:(void (^)(NSString *mp3Path, BOOL finished))completeCallback {
+    NSString *path;
+    if ([avAsset.URL.scheme isEqualToString:AlAsset_Library_Scheme]) {
+        path = avAsset.URL.query;
+        if (path.length == 0) {
+            completeCallback(nil, NO);
+            return;
+        }
+        
+    }else {
+        path = avAsset.URL.path;
+        if (!path || ![[NSFileManager defaultManager] fileExistsAtPath:path]) {
+            completeCallback(nil, NO);
+            return;
+        }
+    }
+    
+    NSString *mp3Path = [ImageCompressor generateCacheFilePath:@"m4a"];;
+
+    if ([[NSFileManager defaultManager] fileExistsAtPath:mp3Path]) {
+        if (completeCallback)
+            completeCallback(mp3Path, YES);
+        return;
+    }
+
+    NSURL *mp3Url;
+    NSArray *compatiblePresets = [AVAssetExportSession exportPresetsCompatibleWithAsset:avAsset];
+    
+    if ([compatiblePresets containsObject:qualityConstant]) {
+        AVAssetExportSession *exportSession = [[AVAssetExportSession alloc]
+                                               initWithAsset:avAsset
+                                               presetName:AVAssetExportPresetAppleM4A];
+
+        mp3Url = [NSURL fileURLWithPath:mp3Path];
+        exportSession.outputURL = mp3Url;
+        exportSession.shouldOptimizeForNetworkUse = YES;
+        exportSession.outputFileType = AVFileTypeAppleM4A;
+        
+ 
+        [exportSession exportAsynchronouslyWithCompletionHandler:^{
+            BOOL finished = NO;
+            switch ([exportSession status]) {
+                case AVAssetExportSessionStatusFailed:
+                    NSLog(@"AVAssetExportSessionStatusFailed, error:%@.", exportSession.error);
+                    break;
+
+                case AVAssetExportSessionStatusCancelled:
+                    NSLog(@"AVAssetExportSessionStatusCancelled.");
+                    break;
+
+                case AVAssetExportSessionStatusCompleted:
+                    NSLog(@"AVAssetExportSessionStatusCompleted.");
+                    finished = YES;
+                    break;
+
+                case AVAssetExportSessionStatusUnknown:
+                    NSLog(@"AVAssetExportSessionStatusUnknown");
+                    break;
+
+                case AVAssetExportSessionStatusWaiting:
+                    NSLog(@"AVAssetExportSessionStatusWaiting");
+                    break;
+
+                case AVAssetExportSessionStatusExporting:
+                    NSLog(@"AVAssetExportSessionStatusExporting");
+                    break;
+
+            }
+
+            if (completeCallback)
+                completeCallback(mp3Path, finished);
+        }];
+        
+    }
+}
+
+- (void)compress_audio:(NSString *)fileUrl optionMap:(NSDictionary *)optionMap resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject {
+    @try {
+            if([fileUrl containsString:@"file://"])
+            {
+                fileUrl=[fileUrl stringByReplacingOccurrencesOfString:@"file://"
+                                                        withString:@""];
+            }
+            NSFileManager *fileManager = [NSFileManager defaultManager];
+            BOOL isDir;
+            if (![fileManager fileExistsAtPath:fileUrl isDirectory:&isDir] || isDir){
+                NSError *err = [NSError errorWithDomain:@"file not found" code:-15 userInfo:nil];
+                reject([NSString stringWithFormat: @"%lu", (long)err.code], err.localizedDescription, err);
+                return;
+            }
+
+              NSDictionary *assetOptions = @{AVURLAssetPreferPreciseDurationAndTimingKey: @YES};
+              AVURLAsset *asset = [AVURLAsset URLAssetWithURL:[NSURL fileURLWithPath:fileUrl] options:assetOptions];
+            NSString *quality=[optionMap objectForKey:@"quality"];
+            NSString *qualityConstant=[self getAudioQualityConstant:quality];
+            [self audo_compress_helper:asset qualityConstant:qualityConstant complete:^(NSString *mp3Path, BOOL finished) {
+                if(finished)
+                {
+                    resolve([NSString stringWithFormat: @"file:/%@", mp3Path]);
+                }
+                else
+                {
+                    reject(@"Error", @"Something went wrong", nil);
+                }
+                
+            }];
+           
+        }
+        @catch (NSException *exception) {
+            reject(exception.name, exception.reason, nil);
+        }
+}
+
+- (void)generateFilePath:(NSString *)extension resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject {
+    @try {
+            NSString *outputUri =[ImageCompressor generateCacheFilePath:extension];
+            resolve(outputUri);
+        }
+        @catch (NSException *exception) {
+            reject(exception.name, exception.reason, nil);
+        }
+}
+
+- (void)getRealPath:(NSString *)path type:(NSString *)type resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject {
+    @try {
+            if([type isEqualToString:@"video"])
+            {
+                [ImageCompressor getAbsoluteVideoPath:path uuid:@"" completionHandler:^(NSString* absoluteImagePath){
+                    resolve(absoluteImagePath);
+                }];
+            }
+            else
+            {
+                [ImageCompressor getAbsoluteImagePath:path uuid:@"test" completionHandler:^(NSString* absoluteImagePath){
+                    resolve(absoluteImagePath);
+                }];
+            }
+        }
+        @catch (NSException *exception) {
+            reject(exception.name, exception.reason, nil);
+        }
+}
+
+- (void)getVideoMetaData:(NSString *)filePath resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject {
+    @try {
+        [ImageCompressor getAbsoluteVideoPath:filePath uuid:@"" completionHandler:^(NSString *absoluteImagePath) {
+                if([absoluteImagePath containsString:@"file://"])
+                {
+                    absoluteImagePath=[absoluteImagePath stringByReplacingOccurrencesOfString:@"file://"
+                                                            withString:@""];
+                }
+                NSFileManager *fileManager = [NSFileManager defaultManager];
+
+                  BOOL isDir;
+                  if (![fileManager fileExistsAtPath:absoluteImagePath isDirectory:&isDir] || isDir){
+                    NSError *err = [NSError errorWithDomain:@"file not found" code:-15 userInfo:nil];
+                    reject([NSString stringWithFormat: @"%lu", (long)err.code], err.localizedDescription, err);
+                    return;
+                  }
+                NSDictionary *attrs = [fileManager attributesOfItemAtPath: absoluteImagePath error: NULL];
+                UInt32 fileSize = [attrs fileSize];
+                NSString *fileSizeString = [@(fileSize) stringValue];
+
+                  NSMutableDictionary *result = [NSMutableDictionary new];
+                  NSDictionary *assetOptions = @{AVURLAssetPreferPreciseDurationAndTimingKey: @YES};
+                  AVURLAsset *asset = [AVURLAsset URLAssetWithURL:[NSURL fileURLWithPath:absoluteImagePath] options:assetOptions];\
+                  AVAssetTrack *avAsset = [[asset tracksWithMediaType:AVMediaTypeVideo] objectAtIndex:0];
+                  CGSize size = [avAsset naturalSize];
+                  NSString *extension = [[absoluteImagePath lastPathComponent] pathExtension];
+                  CMTime time = [asset duration];
+                  int seconds = ceil(time.value/time.timescale);
+                  [result setObject:[NSString stringWithFormat: @"%.2f", size.width] forKey:@"width"];
+                  [result setObject:[NSString stringWithFormat: @"%.2f", size.height] forKey:@"height"];
+                  [result setObject:extension forKey:@"extension"];
+                  [result setObject:fileSizeString forKey:@"size"];
+                  [result setObject:[@(seconds) stringValue] forKey:@"duration"];
+                  NSArray *keys = [NSArray arrayWithObjects:@"commonMetadata", nil];
+                  [asset loadValuesAsynchronouslyForKeys:keys completionHandler:^{
+                    // string keys
+                    for (NSString *key in [self metadatas]) {
+                      NSArray *items = [AVMetadataItem metadataItemsFromArray:asset.commonMetadata
+                                                                     withKey:key
+                                                                    keySpace:AVMetadataKeySpaceCommon];
+                      for (AVMetadataItem *item in items) {
+                        [result setObject:item.value forKey:key];
+                      }
+                    }
+                    resolve(result);
+                  }];
+            }];
+        }
+        @catch (NSException *exception) {
+            reject(exception.name, exception.reason, nil);
+        }
+}
+
+- (void)image_compress:(NSString *)imagePath optionMap:(NSDictionary *)optionMap resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject {
+    @try {
+            ImageCompressorOptions *options = [ImageCompressorOptions fromDictionary:optionMap];
+            [ImageCompressor getAbsoluteImagePath:imagePath uuid:options.uuid completionHandler:^(NSString* absoluteImagePath){
+                if(options.autoCompress)
+                {
+                    NSString *result = [ImageCompressor autoCompressHandler:absoluteImagePath options:options];
+                    resolve(result);
+                }
+                else
+                {
+                    NSString *result = [ImageCompressor manualCompressHandler:absoluteImagePath options:options];
+                    resolve(result);
+                }
+                [MediaCache removeCompletedImagePath:absoluteImagePath];
+            }];
+            
+        }
+        @catch (NSException *exception) {
+            reject(exception.name, exception.reason, nil);
+        }
+}
+
+- (void)getFileSize:(NSString *)filePath resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject {
+    @try {
+        if([filePath hasPrefix:@"http://"]||[filePath hasPrefix:@"https://"])
+        {
+            [ImageCompressor getFileSizeFromURL:filePath completion:^(NSNumber *fileSize, NSError *error) {
+                if (error) {
+                        NSLog(@"Error: %@", error.localizedDescription);
+                    } else {
+                        NSLog(@"File size: %@", fileSize);
+                        resolve(fileSize);
+                    }
+            }];
+
+        }
+        else
+        {
+            if([filePath containsString:@"file://"])
+            {
+                filePath=[filePath stringByReplacingOccurrencesOfString:@"file://"
+                                                             withString:@""];
+            }
+            NSFileManager *fileManager = [NSFileManager defaultManager];
+            BOOL isDir;
+            if (![fileManager fileExistsAtPath:filePath isDirectory:&isDir] || isDir){
+                NSError *err = [NSError errorWithDomain:@"file not found" code:-15 userInfo:nil];
+                reject([NSString stringWithFormat: @"%lu", (long)err.code], err.localizedDescription, err);
+                return;
+            }
+            NSDictionary *attrs = [fileManager attributesOfItemAtPath: filePath error: NULL];
+            UInt32 fileSize = [attrs fileSize];
+            NSString *fileSizeString = [@(fileSize) stringValue];
+            resolve(fileSizeString);
+       }
+       
+    }
+    @catch (NSException *exception) {
+        reject(exception.name, exception.reason, nil);
+    }
+}
+
+// Don't compile this code when we build for the old architecture.
+#ifdef RCT_NEW_ARCH_ENABLED
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
+    (const facebook::react::ObjCTurboModule::InitParams &)params
+{
+    return std::make_shared<facebook::react::NativeCompressorSpecJSI>(params);
+}
+#endif
+
+
+@end
+
+
+@interface RCT_EXTERN_MODULE(VideoCompressor, RCTEventEmitter)
+
+RCT_EXTERN_METHOD(compress:(NSString *)fileUrl
+                 withOptions:(NSDictionary *)options
+                 withResolver:(RCTPromiseResolveBlock)resolve
+                 withRejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(upload:(NSString *)fileUrl
+                 withOptions:(NSDictionary *)options
+                 withResolver:(RCTPromiseResolveBlock)resolve
+                 withRejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(activateBackgroundTask: (NSDictionary *)options
+                 withResolver:(RCTPromiseResolveBlock)resolve
+                 withRejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(deactivateBackgroundTask: (NSDictionary *)options
+                 withResolver:(RCTPromiseResolveBlock)resolve
+                 withRejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(cancelCompression:(NSString *)uuid)
+
+// Don't compile this code when we build for the old architecture.
+#ifdef RCT_NEW_ARCH_ENABLED
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
+    (const facebook::react::ObjCTurboModule::InitParams &)params
+{
+    return std::make_shared<facebook::react::NativeVideoCompressorSpecJSI>(params);
+}
+#endif
+
+@end

package/ios/Compressor.xcodeproj/project.pbxproj

@@ -7,7 +7,7 @@
 	objects = {
 
 /* Begin PBXBuildFile section */
-		188666C92668C616006FF392 /* VideoCompressor.swift in Sources */ = {isa = PBXBuildFile; fileRef = 188657BA26612A1D006FF392 /* VideoCompressor.swift */; };
+		5E555C0D2413F4C50049A1A2 /* Compressor.mm in Sources */ = {isa = PBXBuildFile; fileRef = B3E7B5891CC2AC0600A0062D /* Compressor.mm */; };
 /* End PBXBuildFile section */
 
 /* Begin PBXCopyFilesBuildPhase section */
@@ -24,11 +24,8 @@
 
 /* Begin PBXFileReference section */
 		134814201AA4EA6300B7C361 /* libCompressor.a */ = {isa = PBXFileReference; explicitFileType = archive.ar; includeInIndex = 0; path = libCompressor.a; sourceTree = BUILT_PRODUCTS_DIR; };
-		188657B826612A1C006FF392 /* Compressor-Bridging-Header.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = "Compressor-Bridging-Header.h"; sourceTree = "<group>"; };
-		188657BA26612A1D006FF392 /* VideoCompressor.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = VideoCompressor.swift; sourceTree = "<group>"; };
-		18866CD1266E224C006FF392 /* Image */ = {isa = PBXFileReference; lastKnownFileType = folder; path = Image; sourceTree = "<group>"; };
 		B3E7B5881CC2AC0600A0062D /* Compressor.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Compressor.h; sourceTree = "<group>"; };
-		B3E7B5891CC2AC0600A0062D /* Compressor.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = Compressor.m; sourceTree = "<group>"; };
+		B3E7B5891CC2AC0600A0062D /* Compressor.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = Compressor.mm; sourceTree = "<group>"; };
 /* End PBXFileReference section */
 
 /* Begin PBXFrameworksBuildPhase section */
@@ -50,30 +47,11 @@
 			name = Products;
 			sourceTree = "<group>";
 		};
-		188657B5266127EC006FF392 /* Video */ = {
-			isa = PBXGroup;
-			children = (
-				188657BA26612A1D006FF392 /* VideoCompressor.swift */,
-			);
-			path = Video;
-			sourceTree = "<group>";
-		};
-		188657B7266127FF006FF392 /* Audio */ = {
-			isa = PBXGroup;
-			children = (
-			);
-			path = Audio;
-			sourceTree = "<group>";
-		};
 		58B511D21A9E6C8500147676 = {
 			isa = PBXGroup;
 			children = (
-				188657B826612A1C006FF392 /* Compressor-Bridging-Header.h */,
-				18866CD1266E224C006FF392 /* Image */,
-				188657B7266127FF006FF392 /* Audio */,
-				188657B5266127EC006FF392 /* Video */,
 				B3E7B5881CC2AC0600A0062D /* Compressor.h */,
-				B3E7B5891CC2AC0600A0062D /* Compressor.m */,
+				B3E7B5891CC2AC0600A0062D /* Compressor.mm */,
 				134814211AA4EA7D00B7C361 /* Products */,
 			);
 			sourceTree = "<group>";
@@ -109,7 +87,6 @@
 				TargetAttributes = {
 					58B511DA1A9E6C8500147676 = {
 						CreatedOnToolsVersion = 6.1.1;
-						LastSwiftMigration = 1240;
 					};
 				};
 			};
@@ -136,7 +113,7 @@
 			isa = PBXSourcesBuildPhase;
 			buildActionMask = 2147483647;
 			files = (
-				188666C92668C616006FF392 /* VideoCompressor.swift in Sources */,
+				B3E7B58A1CC2AC0600A0062D /* Compressor.mm in Sources */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;
 		};
@@ -171,6 +148,7 @@
 				COPY_PHASE_STRIP = NO;
 				ENABLE_STRICT_OBJC_MSGSEND = YES;
 				ENABLE_TESTABILITY = YES;
+				"EXCLUDED_ARCHS[sdk=*]" = arm64;
 				GCC_C_LANGUAGE_STANDARD = gnu99;
 				GCC_DYNAMIC_NO_PIC = NO;
 				GCC_NO_COMMON_BLOCKS = YES;
@@ -221,6 +199,7 @@
 				COPY_PHASE_STRIP = YES;
 				ENABLE_NS_ASSERTIONS = NO;
 				ENABLE_STRICT_OBJC_MSGSEND = YES;
+				"EXCLUDED_ARCHS[sdk=*]" = arm64;
 				GCC_C_LANGUAGE_STANDARD = gnu99;
 				GCC_NO_COMMON_BLOCKS = YES;
 				GCC_WARN_64_TO_32_BIT_CONVERSION = YES;
@@ -239,41 +218,32 @@
 		58B511F01A9E6C8500147676 /* Debug */ = {
 			isa = XCBuildConfiguration;
 			buildSettings = {
-				CLANG_ENABLE_MODULES = YES;
 				HEADER_SEARCH_PATHS = (
 					"$(inherited)",
 					/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/include,
 					"$(SRCROOT)/../../../React/**",
 					"$(SRCROOT)/../../react-native/React/**",
 				);
-				LD_RUNPATH_SEARCH_PATHS = "$(inherited) @executable_path/Frameworks @loader_path/Frameworks";
 				LIBRARY_SEARCH_PATHS = "$(inherited)";
 				OTHER_LDFLAGS = "-ObjC";
 				PRODUCT_NAME = Compressor;
 				SKIP_INSTALL = YES;
-				SWIFT_OBJC_BRIDGING_HEADER = "Video/Compressor-Bridging-Header.h";
-				SWIFT_OPTIMIZATION_LEVEL = "-Onone";
-				SWIFT_VERSION = 5.0;
 			};
 			name = Debug;
 		};
 		58B511F11A9E6C8500147676 /* Release */ = {
 			isa = XCBuildConfiguration;
 			buildSettings = {
-				CLANG_ENABLE_MODULES = YES;
 				HEADER_SEARCH_PATHS = (
 					"$(inherited)",
 					/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/include,
 					"$(SRCROOT)/../../../React/**",
 					"$(SRCROOT)/../../react-native/React/**",
 				);
-				LD_RUNPATH_SEARCH_PATHS = "$(inherited) @executable_path/Frameworks @loader_path/Frameworks";
 				LIBRARY_SEARCH_PATHS = "$(inherited)";
 				OTHER_LDFLAGS = "-ObjC";
 				PRODUCT_NAME = Compressor;
 				SKIP_INSTALL = YES;
-				SWIFT_OBJC_BRIDGING_HEADER = "Video/Compressor-Bridging-Header.h";
-				SWIFT_VERSION = 5.0;
 			};
 			name = Release;
 		};

package/ios/Image/ImageCompressor.h

@@ -1,17 +1,22 @@
 #import <UIKit/UIKit.h>
-
+#import <React/RCTEventEmitter.h>
+#import "Compressor.h"
 #import "ImageCompressorOptions.h"
 
-@interface ImageCompressor : NSObject
+@interface ImageCompressor : RCTEventEmitter<NSObject>
 + (UIImage *)decodeImage:(NSString *)base64;
 + (UIImage *)loadImage:(NSString *)path;
 + (NSString *)generateCacheFilePath:(NSString *)extension;
 
 + (UIImage *)manualResize:(UIImage *)image maxWidth:(int)maxWidth maxHeight:(int)maxHeight;
-+(NSString *)manualCompressHandler:(NSString *)imagePath options:(ImageCompressorOptions*)options;
-+(NSString *)autoCompressHandler:(NSString *)imagePath options:(ImageCompressorOptions*)options;
-+ (NSString *)manualCompress:(UIImage *)image output:(enum OutputType)output quality:(float)quality outputExtension:(NSString*)outputExtension isBase64:(Boolean)isBase64;
++ (NSString *)manualCompressHandler:(NSString *)imagePath options:(ImageCompressorOptions *)options;
++ (NSString *)autoCompressHandler:(NSString *)imagePath options:(ImageCompressorOptions *)options;
++ (NSString *)manualCompress:(UIImage *)image output:(enum OutputType)output quality:(float)quality outputExtension:(NSString *)outputExtension isBase64:(Boolean)isBase64;
 + (UIImage *)scaleAndRotateImage:(UIImage *)image;
-+ (void)getAbsoluteImagePath:(NSString *)imagePath completionHandler:(void (^)(NSString *absoluteImagePath))completionHandler;
-+(void)getAbsoluteVideoPath:(NSString *)videoPath completionHandler:(void (^)(NSString *absoluteImagePath))completionHandler;
++ (void)getAbsoluteImagePath:(NSString *)imagePath uuid:(NSString *)uuid completionHandler:(void (^)(NSString *absoluteImagePath))completionHandler;
++ (void)getAbsoluteVideoPath:(NSString *)videoPath uuid:(NSString *)uuid completionHandler:(void (^)(NSString *absoluteImagePath))completionHandler;
++ (void)downloadFileAndSaveToCache:(NSString *)fileUrl;
++ (void)getFileSizeFromURL:(NSString *)urlString completion:(void (^)(NSNumber *fileSize, NSError *error))completion;
++ (void)initCompressorInstance:(Compressor*)instance;
++ (void)initVideoCompressorInstance:(id)object;
 @end