react-native-compressor 0.5.12 → 0.5.17

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

@@ -1,94 +1,60 @@
 package com.reactnativecompressor.Video.AutoVideoCompression;
 
-import android.media.MediaCodecInfo;
 import android.media.MediaMetadataRetriever;
-import android.media.session.MediaController;
 import android.net.Uri;
-import android.os.Build;
 
 import androidx.annotation.Nullable;
 
-import com.facebook.react.bridge.Arguments;
 import com.facebook.react.bridge.Promise;
 import com.facebook.react.bridge.ReactApplicationContext;
 import com.facebook.react.bridge.ReactContext;
 import com.facebook.react.bridge.WritableMap;
 import com.facebook.react.modules.core.DeviceEventManagerModule;
 import com.reactnativecompressor.Video.VideoCompressorHelper;
-import com.zolad.videoslimmer.VideoSlimmer;
+import static com.reactnativecompressor.Utils.Utils.compressVideo;
 
 import java.io.File;
 
 import static com.reactnativecompressor.Utils.Utils.generateCacheFilePath;
 
 public class AutoVideoCompression {
-  static int videoCompressionThreshold=10;
-  static int currentVideoCompression=0;
-
   public static void createCompressionSettings(String fileUrl,VideoCompressorHelper options,Promise promise, ReactApplicationContext reactContext) {
     float maxSize = options.maxSize;
     float minimumFileSizeForCompress=options.minimumFileSizeForCompress;
     try{
-    Uri uri= Uri.parse(fileUrl);
-    String srcPath = uri.getPath();
-    MediaMetadataRetriever metaRetriever = new MediaMetadataRetriever();
-    metaRetriever.setDataSource(srcPath);
-    File file=new File(srcPath);
-    float sizeInBytes = file.length();
-    float sizeInMb = sizeInBytes / (1024 * 1024);
-    if(sizeInMb>minimumFileSizeForCompress)
-    {
-      String destinationPath = generateCacheFilePath("mp4", reactContext);
-      int actualHeight =Integer.parseInt(metaRetriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_VIDEO_HEIGHT));
-      int actualWidth = Integer.parseInt(metaRetriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_VIDEO_WIDTH));
-      int bitrate = Integer.parseInt(metaRetriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_BITRATE));
-
-      float scale = actualWidth > actualHeight ? maxSize / actualWidth : maxSize / actualHeight;
-      int resultWidth = Math.round(actualWidth * scale / 2) * 2;
-      int resultHeight = Math.round(actualHeight * scale / 2) * 2;
-
-      float videoBitRate = makeVideoBitrate(
-        actualHeight, actualWidth,
-        bitrate,
-        resultHeight, resultWidth
-      );
+      Uri uri= Uri.parse(fileUrl);
+      String srcPath = uri.getPath();
+      MediaMetadataRetriever metaRetriever = new MediaMetadataRetriever();
+      metaRetriever.setDataSource(srcPath);
+      File file=new File(srcPath);
+      float sizeInBytes = file.length();
+      float sizeInMb = sizeInBytes / (1024 * 1024);
+      if(sizeInMb>minimumFileSizeForCompress)
+      {
+        String destinationPath = generateCacheFilePath("mp4", reactContext);
+        int actualHeight =Integer.parseInt(metaRetriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_VIDEO_HEIGHT));
+        int actualWidth = Integer.parseInt(metaRetriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_VIDEO_WIDTH));
+        int bitrate = Integer.parseInt(metaRetriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_BITRATE));
 
-      VideoSlimmer.convertVideo(srcPath, destinationPath, resultWidth, resultHeight, (int) videoBitRate, new VideoSlimmer.ProgressListener() {
-        @Override
-        public void onStart() {
-          //convert start
-        }
-        @Override
-        public void onFinish(boolean result) {
-          //convert finish,result(true is success,false is fail)
-          promise.resolve("file:/"+destinationPath);
-        }
-        @Override
-        public void onProgress(float percent) {
-          int roundProgress=Math.round(percent);
-          if(roundProgress%videoCompressionThreshold==0&&roundProgress>currentVideoCompression) {
-            WritableMap params = Arguments.createMap();
-            WritableMap data = Arguments.createMap();
-            params.putString("uuid", options.uuid);
-            data.putDouble("progress", percent / 100);
-            params.putMap("data", data);
-            sendEvent(reactContext, "videoCompressProgress", params);
-            currentVideoCompression=roundProgress;
-          }
-        }
-      });
+        float scale = actualWidth > actualHeight ? maxSize / actualWidth : maxSize / actualHeight;
+        int resultWidth = Math.round(actualWidth * scale / 2) * 2;
+        int resultHeight = Math.round(actualHeight * scale / 2) * 2;
 
+        float videoBitRate = makeVideoBitrate(
+          actualHeight, actualWidth,
+          bitrate,
+          resultHeight, resultWidth
+        );
+        compressVideo(srcPath, destinationPath, resultWidth, resultHeight,  videoBitRate,options.uuid,promise,reactContext);
       }
       else
       {
         promise.resolve(fileUrl);
       }
+
     } catch (Exception ex) {
       promise.reject(ex);
     }
-    finally {
-      currentVideoCompression=0;
-    }
   }
 
   public static int makeVideoBitrate(int originalHeight, int originalWidth, int originalBitrate, int height, int width) {

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

@@ -8,7 +8,6 @@ import android.os.PowerManager;
 
 import androidx.annotation.Nullable;
 
-import com.facebook.react.bridge.Arguments;
 import com.facebook.react.bridge.LifecycleEventListener;
 import com.facebook.react.bridge.Promise;
 import com.facebook.react.bridge.ReactApplicationContext;
@@ -17,13 +16,12 @@ import com.facebook.react.bridge.ReadableMap;
 import com.facebook.react.bridge.ReadableMapKeySetIterator;
 import com.facebook.react.bridge.WritableMap;
 import com.facebook.react.modules.core.DeviceEventManagerModule;
-import com.reactnativecompressor.Image.utils.ImageCompressorOptions;
 import com.reactnativecompressor.Utils.FileUplaoder.FileUploader;
 import com.reactnativecompressor.Video.AutoVideoCompression.AutoVideoCompression;
-import com.zolad.videoslimmer.VideoSlimmer;
 
 import java.util.UUID;
 
+import static com.reactnativecompressor.Utils.Utils.compressVideo;
 import static com.reactnativecompressor.Utils.Utils.generateCacheFilePath;
 
 public class VideoCompressorHelper {
@@ -50,8 +48,8 @@ public class VideoCompressorHelper {
   };
 
   private static void  sendEventString(ReactContext reactContext,
-                               String eventName,
-                               @Nullable String params) {
+                                       String eventName,
+                                       @Nullable String params) {
     reactContext
       .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
       .emit(eventName, params);
@@ -118,7 +116,7 @@ public class VideoCompressorHelper {
         case "maxSize":
           options.maxSize = (float) map.getDouble(key);
           break;
-          case "uuid":
+        case "uuid":
           options.uuid = map.getString(key);
           break;
         case "minimumFileSizeForCompress":
@@ -166,44 +164,10 @@ public class VideoCompressorHelper {
         }
       }
       float videoBitRate = (options.bitrate>0)?options.bitrate: (float) (height * width * 1.5);
-
-      VideoSlimmer.convertVideo(srcPath, destinationPath, width, height, (int) videoBitRate, new VideoSlimmer.ProgressListener() {
-
-
-        @Override
-        public void onStart() {
-          //convert start
-
-        }
-
-        @Override
-        public void onFinish(boolean result) {
-          //convert finish,result(true is success,false is fail)
-          promise.resolve("file:/"+destinationPath);
-        }
-
-
-        @Override
-        public void onProgress(float percent) {
-          int roundProgress=Math.round(percent);
-          if(roundProgress%videoCompressionThreshold==0&&roundProgress>currentVideoCompression) {
-            WritableMap params = Arguments.createMap();
-            WritableMap data = Arguments.createMap();
-            params.putString("uuid", options.uuid);
-            data.putDouble("progress", percent / 100);
-            params.putMap("data", data);
-            sendEvent(reactContext, "videoCompressProgress", params);
-            currentVideoCompression=roundProgress;
-          }
-        }
-      });
-
+      compressVideo(srcPath, destinationPath, width, height,  videoBitRate,options.uuid,promise,reactContext);
     } catch (Exception ex) {
       promise.reject(ex);
     }
-    finally {
-      currentVideoCompression=0;
-    }
   }
 
 
@@ -212,4 +176,4 @@ public class VideoCompressorHelper {
   }
 
 
-  }
+}

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

@@ -1,12 +1,11 @@
 package com.reactnativecompressor.Video;
 
-import android.media.MediaMetadataRetriever;
 import android.net.Uri;
+import android.util.Log;
 
 import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
 
-import com.facebook.react.bridge.Arguments;
 import com.facebook.react.bridge.Promise;
 import com.facebook.react.bridge.ReactApplicationContext;
 import com.facebook.react.bridge.ReactContext;
@@ -16,17 +15,18 @@ 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.Image.utils.ImageCompressorOptions;
-import com.zolad.videoslimmer.VideoSlimmer;
+import com.reactnativecompressor.Utils.RealPathUtil;
 
-import static com.reactnativecompressor.Utils.Utils.generateCacheFilePath;
+import static com.reactnativecompressor.Utils.Utils.getRealPath;
 import static com.reactnativecompressor.Video.VideoCompressorHelper.video_activateBackgroundTask_helper;
 import static com.reactnativecompressor.Video.VideoCompressorHelper.video_deactivateBackgroundTask_helper;
 import static com.reactnativecompressor.Video.VideoCompressorHelper.video_upload_helper;
+import static com.reactnativecompressor.Utils.Utils.cancelCompressionHelper;
 
 @ReactModule(name = VideoModule.NAME)
-public class VideoModule extends ReactContextBaseJavaModule {
+public class  VideoModule extends ReactContextBaseJavaModule {
   public static final String NAME = "VideoCompressor";
+  private static final String TAG = "react-native-compessor";
   private final ReactApplicationContext reactContext;
   public VideoModule(ReactApplicationContext reactContext) {
     super(reactContext);
@@ -53,20 +53,28 @@ public class VideoModule extends ReactContextBaseJavaModule {
     String fileUrl,
     ReadableMap optionMap,
     Promise promise) {
-      final VideoCompressorHelper options = VideoCompressorHelper.fromMap(optionMap);
+    final VideoCompressorHelper options = VideoCompressorHelper.fromMap(optionMap);
+    fileUrl=getRealPath(fileUrl,reactContext);
 
-      if(options.compressionMethod==VideoCompressorHelper.CompressionMethod.auto)
-      {
-        VideoCompressorHelper.VideoCompressAuto(fileUrl,options,promise,reactContext);
-      }
-      else
-      {
-        VideoCompressorHelper.VideoCompressManual(fileUrl,options,promise,reactContext);
-      }
+    if(options.compressionMethod==VideoCompressorHelper.CompressionMethod.auto)
+    {
+      VideoCompressorHelper.VideoCompressAuto(fileUrl,options,promise,reactContext);
+    }
+    else
+    {
+      VideoCompressorHelper.VideoCompressManual(fileUrl,options,promise,reactContext);
+    }
 
 
   }
 
+  @ReactMethod
+  public void cancelCompression(
+    String uuid) {
+    cancelCompressionHelper(uuid);
+    Log.d("cancelCompression", uuid);
+  }
+
   @ReactMethod
   public void upload(
     String fileUrl,

package/ios/Compressor-Bridging-Header.h

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

package/ios/Compressor.m

@@ -9,6 +9,30 @@
 #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;
+}
 
 RCT_EXPORT_MODULE()
 
@@ -20,17 +44,19 @@ RCT_EXPORT_METHOD(
     rejecter: (RCTPromiseRejectBlock) reject) {
     @try {
         ImageCompressorOptions *options = [ImageCompressorOptions fromDictionary:optionsDict];
+        [ImageCompressor getAbsoluteImagePath:imagePath 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);
+            }
+        }];
         
-        if(options.autoCompress)
-        {
-            NSString *result = [ImageCompressor autoCompressHandler:imagePath options:options];
-            resolve(result);
-        }
-        else
-        {
-            NSString *result = [ImageCompressor manualCompressHandler:imagePath options:options];
-            resolve(result);
-        }
     }
     @catch (NSException *exception) {
         reject(exception.name, exception.reason, nil);
@@ -176,7 +202,7 @@ RCT_EXPORT_METHOD(
 
 //general
 RCT_EXPORT_METHOD(
-    generateFile: (NSString*) extension
+    generateFilePath: (NSString*) extension
     resolver: (RCTPromiseResolveBlock) resolve
     rejecter: (RCTPromiseRejectBlock) reject) {
     @try {
@@ -188,6 +214,30 @@ RCT_EXPORT_METHOD(
     }
 }
 
+RCT_EXPORT_METHOD(
+    getRealPath: (NSString*) path
+    type: (NSString*) type
+    resolver: (RCTPromiseResolveBlock) resolve
+    rejecter: (RCTPromiseRejectBlock) reject) {
+    @try {
+        if([type isEqualToString:@"video"])
+        {
+            [ImageCompressor getAbsoluteVideoPath:path completionHandler:^(NSString* absoluteImagePath){
+                resolve(absoluteImagePath);
+            }];
+        }
+        else
+        {
+            [ImageCompressor getAbsoluteImagePath:path completionHandler:^(NSString* absoluteImagePath){
+                resolve(absoluteImagePath);
+            }];
+        }
+    }
+    @catch (NSException *exception) {
+        reject(exception.name, exception.reason, nil);
+    }
+}
+
 //general
     RCT_EXPORT_METHOD(
         getFileSize: (NSString*) filePath
@@ -216,6 +266,63 @@ RCT_EXPORT_METHOD(
         }
     }
 
+
+RCT_EXPORT_METHOD(
+    getVideoMetaData: (NSString*) filePath
+    resolver: (RCTPromiseResolveBlock) resolve
+    rejecter: (RCTPromiseRejectBlock) reject) {
+    @try {
+        [ImageCompressor getAbsoluteVideoPath:filePath 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);
+    }
+}
+
 @end
 
 
@@ -239,5 +346,6 @@ RCT_EXTERN_METHOD(deactivateBackgroundTask: (NSDictionary *)options
                  withResolver:(RCTPromiseResolveBlock)resolve
                  withRejecter:(RCTPromiseRejectBlock)reject)
 
-@end
+RCT_EXTERN_METHOD(cancelCompression:(NSString *)uuid)
 
+@end

package/ios/Image/ImageCompressor.h

@@ -12,4 +12,6 @@
 +(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;
 @end

package/ios/Image/ImageCompressor.m

@@ -1,7 +1,12 @@
 #import <Accelerate/Accelerate.h>
 #import <CoreGraphics/CoreGraphics.h>
-
+#import <Photos/Photos.h>
+#import <React/RCTUtils.h>
+#import <React/RCTImageLoader.h>
 #import "ImageCompressor.h"
+#import <React/RCTConvert.h>
+#import <Foundation/Foundation.h>
+#import <MobileCoreServices/MobileCoreServices.h>
 
 @implementation ImageCompressor
 + (CGSize) findTargetSize: (UIImage *) image maxWidth: (int) maxWidth maxHeight: (int) maxHeight {
@@ -288,4 +293,151 @@
         return returnablePath;
 }
 
++(void)getAbsoluteImagePath:(NSString *)imagePath 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);
+    } 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);
+    NSString *path =[self generateCacheFilePath:@"jpg"];
+  [[NSFileManager defaultManager] createFileAtPath:path contents:imageData attributes:NULL];
+  return path;
+}
+
+/// for video
+    
++(void)getAbsoluteVideoPath:(NSString *)videoPath completionHandler:(void (^)(NSString *absoluteImagePath))completionHandler
+{
+
+    if (![videoPath containsString:@"ph://"]) {
+      completionHandler(videoPath);
+      return;
+    }
+    NSString *assetId =[videoPath stringByReplacingOccurrencesOfString:@"ph://"
+                                                      withString:@""];
+    AVFileType outputFileType = AVFileTypeMPEG4;
+    NSString *pressetType = AVAssetExportPresetPassthrough;
+    
+    // Throwing some errors to the user if he is not careful enough
+    if ([assetId isEqualToString:@""]) {
+        NSError *error = [NSError errorWithDomain:@"RNGalleryManager" code: -91 userInfo:nil];
+        @throw([NSException exceptionWithName:error reason:error userInfo:nil]);
+        return;
+    }
+    
+    // Getting Video Asset
+    NSArray* localIds = [NSArray arrayWithObjects: assetId, nil];
+    PHAsset * _Nullable videoAsset = [PHAsset fetchAssetsWithLocalIdentifiers:localIds options:nil].firstObject;
+    
+    // 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));
+    
+    // Creating output url and temp file name
+    NSString *path =[self generateCacheFilePath:extension];
+    NSURL *outputUrl = [NSURL URLWithString:[@"file://" stringByAppendingString:path]];
+    
+    // Setting video export session options
+    PHVideoRequestOptions *videoRequestOptions = [[PHVideoRequestOptions alloc] init];
+    videoRequestOptions.networkAccessAllowed = YES;
+    videoRequestOptions.deliveryMode = PHVideoRequestOptionsDeliveryModeHighQualityFormat;
+    
+    // Creating new export session
+    [[PHImageManager defaultManager] requestExportSessionForVideo:videoAsset options:videoRequestOptions exportPreset:pressetType resultHandler:^(AVAssetExportSession * _Nullable exportSession, NSDictionary * _Nullable info) {
+        
+        exportSession.shouldOptimizeForNetworkUse = YES;
+        exportSession.outputFileType = outputFileType;
+        exportSession.outputURL = outputUrl;
+        // Converting the video and waiting to see whats going to happen
+        [exportSession exportAsynchronouslyWithCompletionHandler:^{
+            switch ([exportSession status])
+            {
+                case AVAssetExportSessionStatusFailed:
+                {
+                    NSError* error = exportSession.error;
+                    NSString *codeWithDomain = [NSString stringWithFormat:@"E%@%zd", error.domain.uppercaseString, error.code];
+                    @throw([NSException exceptionWithName:error reason:error userInfo:nil]);
+                    break;
+                }
+                case AVAssetExportSessionStatusCancelled:
+                {
+                    NSError *error = [NSError errorWithDomain:@"RNGalleryManager" code: -91 userInfo:nil];
+                    @throw([NSException exceptionWithName:error reason:error userInfo:nil]);
+                    break;
+                }
+                case AVAssetExportSessionStatusCompleted:
+                {
+                    completionHandler(outputUrl.absoluteString);
+                    break;
+                }
+                default:
+                {
+                    NSError *error = [NSError errorWithDomain:@"RNGalleryManager" code: -91 userInfo:nil];
+                    @throw([NSException exceptionWithName:@"Unknown status" reason:@"Unknown status" userInfo:nil]);
+                    break;
+                }
+            }
+        }];
+    }];
+}
+
 @end