react-native-compressor 1.3.5-alpha → 1.5.1

package/README.md

@@ -1,9 +1,17 @@
 ### Would you like to support me?
 
+<div align="center">
+<a href="https://github.com/nomi9995?tab=followers">
+    <img src="https://img.shields.io/github/followers/nomi9995?label=Follow%20%40nomi9995&style=social" />
+</a>
+</br>
 <a href="https://www.buymeacoffee.com/numan.dev" target="_blank"><img src="https://www.buymeacoffee.com/assets/img/custom_images/orange_img.png" alt="Buy Me A Coffee" style="height: auto !important;width: auto !important;" ></a>
+</div>
 
 ---
 
+
+
 # react-native-compressor
 
 <!-- Title -->
@@ -26,6 +34,34 @@
 
 **If you find this package useful hit the star** 🌟
 
+# Table of Contents
+<details>
+<summary>Open Table of Contents</summary>
+
+  * [Installation](#installation)
+    + [For React Native](#react-native)
+      - [For React Native<0.65](#for-react-native065)
+      - [For React Native 0.65 or greater](#for-react-native-065-or-greater)
+    + [Managed Expo](#managed-expo)
+  * [Usage](#usage)
+    + [Image](#image)
+        * [Automatic Image Compression Like Whatsapp](#automatic-image-compression-like-whatsapp)
+        * [Manual Image Compression](#manual-image-compression)
+        * [ImageCompressor API Docs](#imagecompressor)
+    + [Video](#video)
+        * [Automatic Video Compression Like Whatsapp](#automatic-video-compression-like-whatsapp)
+        * [Manual Video Compression](#manual-video-compression)
+        * [Cancel Video Compression](#cancel-video-compression)
+        * [Video Api Docs](#video-1)
+    + [Audio](#audio)
+    + [Background Upload](#background-upload)
+- [Other Utilities](#api)
+  * [Background Upload](#background-upload-1)
+  * [Get Metadata Of Video](#get-metadata-of-video)
+  * [Get Real Path](#get-real-path)
+  * [Get Temp file Path](#get-temp-file-path)
+</details>
+
 ## Installation
 
 ### React Native
@@ -33,7 +69,7 @@
 #### For React Native<0.65
 
 ```sh
-yarn add react-native-compressor@0.5.15
+yarn add react-native-compressor@rnlessthan65
 ```
 
 #### For React Native 0.65 or greater
@@ -111,7 +147,7 @@ react-native link react-native-compressor
 
 ### Image
 
-##### For Like Whatsapp Image Compression
+##### Automatic Image Compression Like Whatsapp
 
 ```js
 import { Image } from 'react-native-compressor';
@@ -123,7 +159,7 @@ const result = await Image.compress('file://path_of_file/image.jpg', {
 
 [Here is this package comparison of images compression with WhatsApp](https://docs.google.com/spreadsheets/d/13TsnC1c7NOC9aCjzN6wkKurJQPeGRNwDhWsQOkXQskU/edit?usp=sharing)
 
-##### For manual Compression
+##### Manual Image Compression
 
 ```js
 import { Image } from 'react-native-compressor';
@@ -136,7 +172,7 @@ const result = await Image.compress('file://path_of_file/image.jpg', {
 
 ### Video
 
-##### For Like Whatsapp Video Compression
+##### Automatic Video Compression Like Whatsapp
 
 ```js
 import { Video } from 'react-native-compressor';
@@ -158,7 +194,7 @@ const result = await Video.compress(
 
 [Here is this package comparison of video compression with WhatsApp](https://docs.google.com/spreadsheets/d/13TsnC1c7NOC9aCjzN6wkKurJQPeGRNwDhWsQOkXQskU/edit#gid=1055406534)
 
-##### For manual Compression
+##### Manual Video Compression
 
 ```js
 import { Video } from 'react-native-compressor';
@@ -334,6 +370,57 @@ type FileSystemUploadOptions = (
 };
 ```
 
+### Get Metadata Of Video
+
+if you want to get metadata of video than you can use this function
+
+```js
+import { getVideoMetaData } from 'react-native-compressor';
+
+const metaData = await getVideoMetaData(filePath);
+```
+
+```
+{
+	"duration": "6",
+	"extension": "mp4",
+	"height": "1080",
+	"size": "16940.0",
+	"width": "1920"
+}
+```
+
+- ###### `getVideoMetaData(path: string)`
+
+### Get Real Path
+
+if you want to convert
+
+- `content://` to `file:///` for android
+- `ph://` to `file:///` for IOS
+
+the you can you `getRealPath` function like this
+
+```js
+import { getRealPath } from 'react-native-compressor';
+
+const realPath = await getRealPath(fileUri, 'video'); //   file://file_path.extension
+```
+
+- ###### `getRealPath(path: string, type: string = 'video'|'image')`
+
+### Get Temp file Path
+
+if you wanna make random file path in cache folder then you can use this method like this
+
+```js
+import { generateFilePath } from 'react-native-compressor';
+
+const randomFilePathForSaveFile = await generateFilePath('mp4'); //   file://file_path.mp4
+```
+
+- ##### `generateFilePath(fileextension: string)`
+
 ## Contributing
 
 See the [contributing guide](CONTRIBUTING.md) to learn how to contribute to the repository and the development workflow.

package/android/build.gradle

@@ -57,6 +57,6 @@ dependencies {
     //noinspection GradleDynamicVersion
   implementation "com.facebook.react:react-native:+"  // From node_modules
   implementation 'io.github.lizhangqu:coreprogress:1.0.2'
-  implementation 'com.github.nomi9995:VideoCompressor:90adcba85a'
+  implementation 'com.github.nomi9995:VideoCompressor:715bcc16e9'
 //   implementation project(path: ':videocompressor')
 }

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

@@ -9,6 +9,7 @@ import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
 import androidx.annotation.RequiresApi;
 
+import com.facebook.react.bridge.Arguments;
 import com.facebook.react.bridge.Promise;
 import com.facebook.react.bridge.ReactApplicationContext;
 import com.facebook.react.bridge.ReactContext;
@@ -20,10 +21,15 @@ import com.facebook.react.module.annotations.ReactModule;
 import com.facebook.react.modules.core.DeviceEventManagerModule;
 import com.reactnativecompressor.Image.ImageCompressor;
 import com.reactnativecompressor.Image.utils.ImageCompressorOptions;
+import com.reactnativecompressor.Utils.Utils;
 import com.reactnativecompressor.Video.VideoCompressorHelper;
 import static com.reactnativecompressor.Utils.Utils.generateCacheFilePath;
+import static com.reactnativecompressor.Utils.Utils.getRealPath;
+
 import com.reactnativecompressor.Audio.AudioCompressor;
 
+import java.io.File;
+
 @ReactModule(name = CompressorModule.NAME)
 public class CompressorModule extends ReactContextBaseJavaModule {
     public static final String NAME = "Compressor";
@@ -54,6 +60,7 @@ public class CompressorModule extends ReactContextBaseJavaModule {
     ReadableMap optionMap,
     Promise promise) {
     try {
+      imagePath=Utils.getRealPath(imagePath,reactContext);
       final ImageCompressorOptions options = ImageCompressorOptions.fromMap(optionMap);
 
       if(options.compressionMethod==ImageCompressorOptions.CompressionMethod.auto)
@@ -98,7 +105,7 @@ public class CompressorModule extends ReactContextBaseJavaModule {
 
   //General
     @ReactMethod
-   public void generateFile(String extension, Promise promise) {
+   public void generateFilePath(String extension, Promise promise) {
      try {
        final String outputUri =generateCacheFilePath(extension,reactContext);
        promise.resolve(outputUri);
@@ -106,4 +113,42 @@ public class CompressorModule extends ReactContextBaseJavaModule {
        promise.reject(e);
      }
    }
+
+  @ReactMethod
+  public void getRealPath(String path,String type, Promise promise) {
+    try {
+      final String realPath =Utils.getRealPath(path,reactContext);
+      promise.resolve("file://"+realPath);
+    } catch (Exception e) {
+      promise.reject(e);
+    }
+  }
+
+  @ReactMethod
+  public void getVideoMetaData(String filePath, Promise promise) {
+    try {
+      filePath=Utils.getRealPath(filePath,reactContext);
+      Uri uri= Uri.parse(filePath);
+      String srcPath = uri.getPath();
+      MediaMetadataRetriever metaRetriever = new MediaMetadataRetriever();
+      metaRetriever.setDataSource(srcPath);
+      File file=new File(srcPath);
+      float sizeInKBs = file.length()/1024;
+      int actualHeight =Integer.parseInt(metaRetriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_VIDEO_HEIGHT));
+      int actualWidth = Integer.parseInt(metaRetriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_VIDEO_WIDTH));
+      long duration = Long.parseLong(metaRetriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_DURATION));
+      String extension = filePath.substring(filePath.lastIndexOf(".")+1);
+
+      WritableMap params = Arguments.createMap();
+      params.putString("size", String.valueOf(sizeInKBs));
+      params.putString("width", String.valueOf(actualWidth));
+      params.putString("height", String.valueOf(actualHeight));
+      params.putString("duration", String.valueOf(duration/1000));
+      params.putString("extension", extension);
+
+      promise.resolve(params);
+    } catch (Exception e) {
+      promise.reject(e);
+    }
+  }
 }

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

@@ -1,5 +1,8 @@
 package com.reactnativecompressor.Utils;
 
+import android.net.Uri;
+import android.util.Log;
+
 import androidx.annotation.Nullable;
 
 import com.facebook.react.bridge.Arguments;
@@ -17,6 +20,7 @@ import java.util.UUID;
 
 public class Utils {
   static int videoCompressionThreshold=10;
+  private static final String TAG = "react-native-compessor";
   static Map<String, VideoCompressTask> compressorExports = new HashMap<>();
 
   public static String generateCacheFilePath(String extension, ReactApplicationContext reactContext){
@@ -43,7 +47,14 @@ public class Utils {
 
       @Override
       public void onError(String errorMessage) {
-        promise.reject("Compression has canncelled");
+        if(errorMessage.equals(("class java.lang.AssertionError")))
+        {
+          promise.resolve(srcPath);
+        }
+        else
+        {
+          promise.reject("Compression has canncelled");
+        }
       }
 
       @Override
@@ -85,4 +96,18 @@ public class Utils {
       .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
       .emit(eventName, params);
   }
+
+  public static String getRealPath(String fileUrl,ReactApplicationContext reactContext){
+    if(fileUrl.startsWith("content://"))
+    {
+      try {
+        Uri uri= Uri.parse(fileUrl);
+        fileUrl= RealPathUtil.getRealPath(reactContext,uri);
+      }
+      catch (Exception ex) {
+        Log.d(TAG, " Please see this issue: https://github.com/Shobbak/react-native-compressor/issues/25");
+      }
+    }
+    return fileUrl;
+  }
 }

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

@@ -17,6 +17,7 @@ import com.facebook.react.module.annotations.ReactModule;
 import com.facebook.react.modules.core.DeviceEventManagerModule;
 import com.reactnativecompressor.Utils.RealPathUtil;
 
+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;
@@ -53,17 +54,7 @@ public class  VideoModule extends ReactContextBaseJavaModule {
     ReadableMap optionMap,
     Promise promise) {
     final VideoCompressorHelper options = VideoCompressorHelper.fromMap(optionMap);
-
-    if(fileUrl.startsWith("content://"))
-    {
-      try {
-        Uri uri= Uri.parse(fileUrl);
-        fileUrl= RealPathUtil.getRealPath(reactContext,uri);
-      }
-      catch (Exception ex) {
-        Log.d(TAG, " Please see this issue: https://github.com/Shobbak/react-native-compressor/issues/25");
-      }
-    }
+    fileUrl=getRealPath(fileUrl,reactContext);
 
     if(options.compressionMethod==VideoCompressorHelper.CompressionMethod.auto)
     {

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
 
 
@@ -242,4 +349,3 @@ RCT_EXTERN_METHOD(deactivateBackgroundTask: (NSDictionary *)options
 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