react-native-compressor 1.7.0 → 1.7.1

package/ios/Compressor.mm

@@ -5,6 +5,7 @@
 #import "Image/ImageCompressorOptions.h"
 #import <React/RCTEventEmitter.h>
 #import <AVFoundation/AVFoundation.h>
+#import "MediaCache.h"
 
 #define AlAsset_Library_Scheme @"assets-library"
 @implementation Compressor
@@ -35,8 +36,18 @@ static NSArray *metadatas;
   return metadatas;
 }
 
+- (instancetype)init {
+    self = [super init];
+    [ImageCompressor initCompressorInstance:self];
+    return self;
+}
+
 RCT_EXPORT_MODULE()
 
++ (BOOL)requiresMainQueueSetup {
+  return NO;
+}
+
 
 //Image
 RCT_EXPORT_METHOD(
@@ -88,6 +99,10 @@ RCT_EXPORT_METHOD(
     [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];
@@ -233,13 +248,13 @@ RCT_EXPORT_METHOD(
     @try {
             if([type isEqualToString:@"video"])
             {
-                [ImageCompressor getAbsoluteVideoPath:path completionHandler:^(NSString* absoluteImagePath){
+                [ImageCompressor getAbsoluteVideoPath:path uuid:@"" completionHandler:^(NSString* absoluteImagePath){
                     resolve(absoluteImagePath);
                 }];
             }
             else
             {
-                [ImageCompressor getAbsoluteImagePath:path completionHandler:^(NSString* absoluteImagePath){
+                [ImageCompressor getAbsoluteImagePath:path uuid:@"test" completionHandler:^(NSString* absoluteImagePath){
                     resolve(absoluteImagePath);
                 }];
             }
@@ -251,7 +266,7 @@ RCT_EXPORT_METHOD(
 
 - (void)getVideoMetaData:(NSString *)filePath resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject {
     @try {
-            [ImageCompressor getAbsoluteVideoPath:filePath completionHandler:^(NSString *absoluteImagePath) {
+        [ImageCompressor getAbsoluteVideoPath:filePath uuid:@"" completionHandler:^(NSString *absoluteImagePath) {
                 if([absoluteImagePath containsString:@"file://"])
                 {
                     absoluteImagePath=[absoluteImagePath stringByReplacingOccurrencesOfString:@"file://"
@@ -305,7 +320,7 @@ RCT_EXPORT_METHOD(
 - (void)image_compress:(NSString *)imagePath optionMap:(NSDictionary *)optionMap resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject {
     @try {
             ImageCompressorOptions *options = [ImageCompressorOptions fromDictionary:optionMap];
-            [ImageCompressor getAbsoluteImagePath:imagePath completionHandler:^(NSString* absoluteImagePath){
+            [ImageCompressor getAbsoluteImagePath:imagePath uuid:options.uuid completionHandler:^(NSString* absoluteImagePath){
                 if(options.autoCompress)
                 {
                     NSString *result = [ImageCompressor autoCompressHandler:absoluteImagePath options:options];
@@ -316,6 +331,7 @@ RCT_EXPORT_METHOD(
                     NSString *result = [ImageCompressor manualCompressHandler:absoluteImagePath options:options];
                     resolve(result);
                 }
+                [MediaCache removeCompletedImagePath:absoluteImagePath];
             }];
             
         }
@@ -326,26 +342,42 @@ RCT_EXPORT_METHOD(
 
 - (void)getFileSize:(NSString *)filePath resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject {
     @try {
-               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);
-           }
+        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.

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

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