@oguzhnatly/react-native-image-manipulator 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Oğuzhan Atalay
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,127 @@
+### `ImageManipulator.manipulate(uri, actions, saveOptions)`
+
+Manipulate the image provided via `uri`. Available modifications are rotating, flipping (mirroring), resizing and cropping. Each invocation results in a new file. With one invocation you can provide a set of actions to perform over the image. Overwriting the source file would not have an effect in displaying the result as images are cached.
+
+#### Arguments
+
+- **uri (_string_)** -- URI of the file to manipulate. Should be in the app's scope.
+- **actions (_array_)** --
+
+  An array of objects representing manipulation options. Each object should have one of the following keys:
+
+  - **resize (_object_)** -- An object of shape `{ width, height }`. Values correspond to the result image dimensions. If you specify only one value, the other will be set automatically to preserve image ratio.
+  - **rotate (_number_)** -- Degrees to rotate the image. Rotation is clockwise when the value is positive and counter-clockwise when negative.
+  - **flip (_object_)** -- An object of shape `{ vertical, horizontal }`. Having a field set to true, flips the image in specified axis.
+  - **crop (_object_)** -- An object of shape `{ originX, originY, width, height }`. Fields specify top-left corner and dimensions of a crop rectangle.
+
+- **saveOptions (_object_)** -- A map defining how modified image should be saved:
+  - **compress (_number_)** -- A value in range 0 - 1 specifying compression level of the result image. 1 means no compression and 0 the highest compression.
+  - **format (_string_)** -- Either `'jpeg'` or `'png'`. Specifies what type of compression should be used and what is the result file extension. PNG compression is lossless but slower, JPEG is faster but the image has visible artifacts. Defaults to `'jpeg'`.
+  - **base64 (_boolean_)** -- Whether to also include the image data in Base64 format.
+
+#### Returns
+
+Returns `{ uri, width, height }` where `uri` is a URI to the modified image (useable as the source for an `Image`/`Video` element), `width, height` specify the dimensions of the image. It can contain also `base64` - it is included if the `base64` saveOption was truthy, and is a string containing the JPEG/PNG (depending on `format`) data of the image in Base64--prepend that with `'data:image/xxx;base64,'` to get a data URI, which you can use as the source for an `Image` element for example (where `xxx` is 'jpeg' or 'png').
+
+### Basic Example
+
+This will first rotate the image 90 degrees clockwise, then flip the rotated image vertically and save it as a PNG.
+
+```javascript
+import React from "react";
+import { Button, TouchableOpacity, Text, View, Image } from "react-native";
+import ImageManipulator from "react-native-image-manipulator";
+
+import Colors from "../constants/Colors";
+
+export default class ImageManipulatorSample extends React.Component {
+  state = {
+    ready: false,
+    image: null
+  };
+
+  componentWillMount() {
+    (async () => {
+      const image = Asset.fromModule(require("../path/to/image.jpg"));
+      await image.downloadAsync();
+      this.setState({
+        ready: true,
+        image
+      });
+    })();
+  }
+
+  render() {
+    return (
+      <View style={{ flex: 1 }}>
+        <View style={{ padding: 10 }}>
+          <Button onPress={this._rotate90andFlip} />
+          {this.state.ready && this._renderImage()}
+        </View>
+      </View>
+    );
+  }
+
+  _rotate90andFlip = async () => {
+    const manipResult = await ImageManipulator.manipulate(
+      this.state.image.localUri || this.state.image.uri,
+      [{ rotate: 90 }, { flip: { vertical: true } }],
+      { format: "png" }
+    );
+    this.setState({ image: manipResult });
+  };
+
+  _renderImage = () => {
+    return (
+      <View
+        style={{
+          marginVertical: 10,
+          alignItems: "center",
+          justifyContent: "center"
+        }}
+      >
+        <Image
+          source={{ uri: this.state.image.localUri || this.state.image.uri }}
+          style={{ width: 300, height: 300, resizeMode: "contain" }}
+        />
+      </View>
+    );
+  };
+}
+```
+
+## Getting started
+
+`$ npm install @oguzhnatly/react-native-image-manipulator --save`
+### OR
+`$ yarn add @oguzhnatly/react-native-image-manipulator`
+
+### Mostly automatic installation
+
+`$ react-native link react-native-image-manipulator`
+
+### Manual installation
+
+#### iOS
+
+1.  In XCode, in the project navigator, right click `Libraries` ➜ `Add Files to [your project's name]`
+2.  Go to `node_modules` ➜ `react-native-image-manipulator` and add `RNImageManipulator.xcodeproj`
+3.  In XCode, in the project navigator, select your project. Add `libRNImageManipulator.a` to your project's `Build Phases` ➜ `Link Binary With Libraries`
+4.  Run your project (`Cmd+R`)<
+
+#### Android
+
+1.  Open up `android/app/src/main/java/[...]/MainActivity.java`
+
+- Add `import com.reactnativeimagemanipulator.RNImageManipulatorPackage;` to the imports at the top of the file
+- Add `new RNImageManipulatorPackage()` to the list returned by the `getPackages()` method
+
+2.  Append the following lines to `android/settings.gradle`:
+    ```
+    include ':react-native-image-manipulator'
+    project(':react-native-image-manipulator').projectDir = new File(rootProject.projectDir, 	'../node_modules/react-native-image-manipulator/android')
+    ```
+3.  Insert the following lines inside the dependencies block in `android/app/build.gradle`:
+    ```
+      compile project(':react-native-image-manipulator')
+    ```

package/android/build.gradle

@@ -0,0 +1,36 @@
+
+buildscript {
+    repositories {
+        google()
+        jcenter()
+    }
+
+    dependencies {
+        classpath 'com.android.tools.build:gradle:3.3.1'
+    }
+}
+
+apply plugin: 'com.android.library'
+
+android {
+    compileSdkVersion 28
+    buildToolsVersion "28.0.3"
+
+    defaultConfig {
+        minSdkVersion 16
+        targetSdkVersion 28
+        versionCode 1
+        versionName "1.0"
+    }
+    lintOptions {
+        abortOnError false
+    }
+}
+
+repositories {
+    mavenCentral()
+}
+
+dependencies {
+    implementation 'com.facebook.react:react-native:+'
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,5 @@
+
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+          package="com.reactnativeimagemanipulator">
+
+</manifest>

package/android/src/main/java/com/reactnativeimagemanipulator/RNImageManipulatorModule.java

@@ -0,0 +1,208 @@
+package com.reactnativeimagemanipulator;
+
+import android.graphics.Bitmap;
+import android.graphics.Matrix;
+import android.net.Uri;
+import android.util.Base64;
+
+import com.facebook.common.executors.CallerThreadExecutor;
+import com.facebook.common.executors.UiThreadImmediateExecutorService;
+import com.facebook.common.references.CloseableReference;
+import com.facebook.datasource.DataSource;
+import com.facebook.drawee.backends.pipeline.Fresco;
+import com.facebook.imagepipeline.common.RotationOptions;
+import com.facebook.imagepipeline.datasource.BaseBitmapDataSubscriber;
+import com.facebook.imagepipeline.image.CloseableImage;
+import com.facebook.imagepipeline.request.ImageRequest;
+import com.facebook.imagepipeline.request.ImageRequestBuilder;
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.WritableMap;
+
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.util.UUID;
+
+public class RNImageManipulatorModule extends ReactContextBaseJavaModule {
+  private static final String DECODE_ERROR_TAG = "E_DECODE_ERR";
+  private static final String ARGS_ERROR_TAG = "E_ARGS_ERR";
+
+  public RNImageManipulatorModule(ReactApplicationContext reactContext) {
+    super(reactContext);
+  }
+
+  @Override
+  public String getName() {
+    return "RNImageManipulator";
+  }
+
+  @ReactMethod
+  public void manipulate(final String uriString, final ReadableArray actions, final ReadableMap saveOptions, final Promise promise) {
+    if (uriString == null || uriString.length() == 0) {
+      promise.reject(ARGS_ERROR_TAG, "Uri passed to ImageManipulator cannot be empty!");
+      return;
+    }
+    ImageRequest imageRequest =
+        ImageRequestBuilder
+            .newBuilderWithSource(Uri.parse(uriString))
+            .setRotationOptions(RotationOptions.autoRotate())
+            .build();
+    final DataSource<CloseableReference<CloseableImage>> dataSource
+        = Fresco.getImagePipeline().fetchDecodedImage(imageRequest, getReactApplicationContext());
+    dataSource.subscribe(new BaseBitmapDataSubscriber() {
+                           @Override
+                           public void onNewResultImpl(Bitmap bitmap) {
+                             if (bitmap != null) {
+                               processBitmapWithActions(bitmap, actions, saveOptions, promise);
+                             } else {
+                               onFailureImpl(dataSource);
+                             }
+                           }
+
+                           @Override
+                           public void onFailureImpl(DataSource dataSource) {
+                             // No cleanup required here.
+                             String basicMessage = "Could not get decoded bitmap of " + uriString;
+                             if (dataSource.getFailureCause() != null) {
+                               promise.reject(DECODE_ERROR_TAG,
+                                   basicMessage + ": " + dataSource.getFailureCause().toString(), dataSource.getFailureCause());
+                             } else {
+                               promise.reject(DECODE_ERROR_TAG, basicMessage + ".");
+                             }
+                           }
+                         },
+        CallerThreadExecutor.getInstance()
+    );
+  }
+
+  private void processBitmapWithActions(Bitmap bmp, ReadableArray actions, ReadableMap saveOptions, Promise promise) {
+    int imageWidth, imageHeight;
+
+    for (int idx = 0; idx < actions.size(); idx ++) {
+      ReadableMap options = actions.getMap(idx);
+
+      imageWidth = bmp.getWidth();
+      imageHeight = bmp.getHeight();
+
+      if (options.hasKey("resize")) {
+        ReadableMap resize = options.getMap("resize");
+        int requestedWidth = 0;
+        int requestedHeight = 0;
+        float imageRatio = 1.0f * imageWidth / imageHeight;
+
+        if (resize.hasKey("width")) {
+          requestedWidth = (int) resize.getDouble("width");
+          requestedHeight = (int) (requestedWidth / imageRatio);
+        }
+        if (resize.hasKey("height")) {
+          requestedHeight = (int) resize.getDouble("height");
+          requestedWidth = requestedWidth == 0 ? (int) (imageRatio * requestedHeight) : requestedWidth;
+        }
+
+        bmp = Bitmap.createScaledBitmap(bmp, requestedWidth, requestedHeight, true);
+      } else if (options.hasKey("rotate")) {
+        int requestedRotation = options.getInt("rotate");
+        Matrix rotationMatrix = new Matrix();
+        rotationMatrix.postRotate(requestedRotation);
+        bmp = Bitmap.createBitmap(bmp, 0, 0, bmp.getWidth(), bmp.getHeight(), rotationMatrix, true);
+      } else if (options.hasKey("flip")) {
+        Matrix rotationMatrix = new Matrix();
+        ReadableMap flip = options.getMap("flip");
+        if (flip.hasKey("horizontal") && flip.getBoolean("horizontal")) {
+          rotationMatrix.postScale(-1, 1);
+        }
+        if (flip.hasKey("vertical") && flip.getBoolean("vertical")) {
+          rotationMatrix.postScale(1, -1);
+        }
+        bmp = Bitmap.createBitmap(bmp, 0, 0, bmp.getWidth(), bmp.getHeight(), rotationMatrix, true);
+      } else if (options.hasKey("crop")) {
+        ReadableMap crop = options.getMap("crop");
+        if (!crop.hasKey("originX") || !crop.hasKey("originY") || !crop.hasKey("width") || !crop.hasKey("height")) {
+          promise.reject("E_INVALID_CROP_DATA", "Invalid crop options has been passed. Please make sure the object contains originX, originY, width and height.");
+          return;
+        }
+        int originX, originY, requestedWidth, requestedHeight;
+        originX = (int) crop.getDouble("originX");
+        originY = (int) crop.getDouble("originY");
+        requestedWidth = (int) crop.getDouble("width");
+        requestedHeight = (int) crop.getDouble("height");
+        if (originX > imageWidth || originY > imageHeight || requestedWidth > bmp.getWidth() || requestedHeight > bmp.getHeight()) {
+          promise.reject("E_INVALID_CROP_DATA", "Invalid crop options has been passed. Please make sure the requested crop rectangle is inside source image.");
+          return;
+        }
+        bmp = Bitmap.createBitmap(bmp, originX, originY, requestedWidth, requestedHeight);
+      }
+    }
+
+    int compressionQuality = 100;
+    if (saveOptions.hasKey("compress")) {
+      compressionQuality = (int) (100 * saveOptions.getDouble("compress"));
+    }
+    String format, extension;
+    Bitmap.CompressFormat compressFormat;
+
+    if (saveOptions.hasKey("format")) {
+      format = saveOptions.getString("format");
+    } else {
+      format = "jpeg";
+    }
+
+    if (format.equals("png")) {
+      compressFormat = Bitmap.CompressFormat.PNG;
+      extension = ".png";
+    } else if (format.equals("jpeg")) {
+      compressFormat = Bitmap.CompressFormat.JPEG;
+      extension = ".jpg";
+    } else {
+      compressFormat = Bitmap.CompressFormat.JPEG;
+      extension = ".jpg";
+    }
+
+    boolean base64 = saveOptions.hasKey("base64") && saveOptions.getBoolean("base64");
+
+    FileOutputStream out = null;
+    ByteArrayOutputStream byteOut = null;
+    String path = null;
+    String base64String = null;
+    try {
+      path = this.getReactApplicationContext().getFilesDir() + "/" + UUID.randomUUID() + extension;
+      out = new FileOutputStream(path);
+      bmp.compress(compressFormat, compressionQuality, out);
+
+      if (base64) {
+        byteOut = new ByteArrayOutputStream();
+        bmp.compress(compressFormat, compressionQuality, byteOut);
+        base64String = Base64.encodeToString(byteOut.toByteArray(), Base64.DEFAULT);
+      }
+    } catch (Exception e) {
+      e.printStackTrace();
+    } finally {
+      try {
+        if (out != null) {
+          out.close();
+        }
+        if (byteOut != null) {
+          byteOut.close();
+        }
+      } catch (IOException e) {
+        e.printStackTrace();
+      }
+    }
+
+    WritableMap response = Arguments.createMap();
+    response.putString("uri", Uri.fromFile(new File(path)).toString());
+    response.putInt("width", bmp.getWidth());
+    response.putInt("height", bmp.getHeight());
+    if (base64) {
+      response.putString("base64", base64String);
+    }
+    promise.resolve(response);
+  }
+}

package/android/src/main/java/com/reactnativeimagemanipulator/RNImageManipulatorPackage.java

@@ -0,0 +1,29 @@
+
+package com.reactnativeimagemanipulator;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+import com.facebook.react.ReactPackage;
+import com.facebook.react.bridge.NativeModule;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.uimanager.ViewManager;
+import com.facebook.react.bridge.JavaScriptModule;
+
+public class RNImageManipulatorPackage implements ReactPackage {
+    @Override
+    public List<NativeModule> createNativeModules(ReactApplicationContext reactContext) {
+      return Arrays.<NativeModule>asList(new RNImageManipulatorModule(reactContext));
+    }
+
+    // Deprecated from RN 0.47
+    public List<Class<? extends JavaScriptModule>> createJSModules() {
+      return Collections.emptyList();
+    }
+
+    @Override
+    public List<ViewManager> createViewManagers(ReactApplicationContext reactContext) {
+      return Collections.emptyList();
+    }
+}

package/index.js

@@ -0,0 +1,5 @@
+import { NativeModules } from "react-native";
+
+const { RNImageManipulator } = NativeModules;
+
+export default RNImageManipulator;

package/ios/ImageUtils.h

@@ -0,0 +1,9 @@
+#import <UIKit/UIKit.h>
+#import <CoreMedia/CoreMedia.h>
+#import <Foundation/Foundation.h>
+
+@interface ImageUtils : NSObject
+
++ (UIImage *)cropImage:(UIImage *)image toRect:(CGRect)rect;
+
+@end

package/ios/ImageUtils.m

@@ -0,0 +1,14 @@
+#import "ImageUtils.h"
+
+@implementation ImageUtils
+
++ (UIImage *)cropImage:(UIImage *)image toRect:(CGRect)rect
+{
+  CGImageRef takenCGImage = image.CGImage;
+  CGImageRef cropCGImage = CGImageCreateWithImageInRect(takenCGImage, rect);
+  image = [UIImage imageWithCGImage:cropCGImage scale:image.scale orientation:image.imageOrientation];
+  CGImageRelease(cropCGImage);
+  return image;
+}
+
+@end

package/ios/RNImageManipulator.h

@@ -0,0 +1,11 @@
+
+#if __has_include("RCTBridgeModule.h")
+#import "RCTBridgeModule.h"
+#else
+#import <React/RCTBridgeModule.h>
+#endif
+
+@interface RNImageManipulator : NSObject <RCTBridgeModule>
+
+@end
+  

package/ios/RNImageManipulator.m

@@ -0,0 +1,200 @@
+#import "RNImageManipulator.h"
+#import "ImageUtils.h"
+#import <React/RCTLog.h>
+#import <Photos/Photos.h>
+
+@implementation RNImageManipulator
+
+RCT_EXPORT_MODULE(RNImageManipulator);
+
+@synthesize bridge = _bridge;
+
+- (void)setBridge:(RCTBridge *)bridge
+{
+  _bridge = bridge;
+}
+
+- (dispatch_queue_t)methodQueue
+{
+  return dispatch_get_main_queue();
+}
+
+RCT_EXPORT_METHOD(manipulate:(NSString *)uri
+                  actions:(NSArray *)actions
+                  saveOptions:(NSDictionary *)saveOptions
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+{
+  NSURL *url = [NSURL URLWithString:uri];
+  NSString *path = [url.path stringByStandardizingPath];
+
+  if ([[url scheme] isEqualToString:@"assets-library"]) {
+    PHFetchResult<PHAsset *> *fetchResult = [PHAsset fetchAssetsWithALAssetURLs:@[url] options:nil];
+    if (fetchResult.count > 0) {
+      PHAsset *asset = fetchResult[0];
+      CGSize size = CGSizeMake([asset pixelWidth], [asset pixelHeight]);
+      PHImageRequestOptions *options = [PHImageRequestOptions new];
+      [options setResizeMode:PHImageRequestOptionsResizeModeExact];
+      [options setNetworkAccessAllowed:YES];
+      [options setSynchronous:NO];
+      [options setDeliveryMode:PHImageRequestOptionsDeliveryModeHighQualityFormat];
+
+      [[PHImageManager defaultManager] requestImageForAsset:asset targetSize:size contentMode:PHImageContentModeAspectFit options:options resultHandler:^(UIImage * _Nullable image, NSDictionary * _Nullable info) {
+        if (!image) {
+          reject(@"E_IMAGE_MANIPULATION_FAILED", [NSString stringWithFormat:@"The file isn't convertable to image. Given path: `%@`.", path], nil);
+          return;
+        }
+        [self manipulateImage:image actions:actions saveOptions:saveOptions resolver:resolve rejecter:reject];
+      }];
+      return;
+    } else {
+      reject(@"E_IMAGE_MANIPULATION_FAILED", [NSString stringWithFormat:@"The file does not exist. Given path: `%@`.", path], nil);
+      return;
+    }
+  } else {
+    if (![[NSFileManager defaultManager] fileExistsAtPath:path]) {
+      reject(@"E_IMAGE_MANIPULATION_FAILED", [NSString stringWithFormat:@"The file does not exist. Given path: `%@`.", path], nil);
+      return;
+    }
+
+    UIImage *image = [[UIImage alloc] initWithContentsOfFile:path];
+    if (image == nil) {
+      reject(@"E_CANNOT_OPEN", @"Could not open provided image", nil);
+      return;
+    }
+
+    [self manipulateImage:image actions:actions saveOptions:saveOptions resolver:resolve rejecter:reject];
+    return;
+  }
+}
+
+-(void)manipulateImage:(UIImage *)image
+               actions:(NSArray *)actions
+           saveOptions:(NSDictionary *)saveOptions
+              resolver:(RCTPromiseResolveBlock)resolve
+              rejecter:(RCTPromiseRejectBlock)reject
+{
+  for (NSDictionary *options in actions) {
+    if (options[@"resize"]) {
+      float imageWidth = image.size.width;
+      float imageHeight = image.size.height;
+      float imageRatio = imageWidth / imageHeight;
+
+      NSInteger requestedWidth = 0;
+      NSInteger requestedHeight = 0;
+      NSDictionary *resize = options[@"resize"];
+      if (resize[@"width"]) {
+        requestedWidth = [(NSNumber *)resize[@"width"] integerValue];
+        requestedHeight = requestedWidth/imageRatio;
+      }
+      if (resize[@"height"]) {
+        requestedHeight = [(NSNumber *)resize[@"height"] integerValue];
+        requestedWidth = requestedWidth == 0 ? imageRatio * requestedHeight : requestedWidth;
+      }
+
+      CGSize requestedSize = CGSizeMake(requestedWidth, requestedHeight);
+      UIGraphicsBeginImageContextWithOptions(requestedSize, NO, 1.0);
+        [image drawInRect:CGRectMake(0, 0, requestedWidth, requestedHeight)];
+        image = UIGraphicsGetImageFromCurrentImageContext();
+      UIGraphicsEndImageContext();
+    } else if (options[@"rotate"]) {
+      float rads = [(NSNumber *)options[@"rotate"] integerValue] * M_PI/180;
+      CGSize size = image.size;
+      UIView *rotatedViewBox = [[UIView alloc] initWithFrame:CGRectMake(0,0,size.width, size.height)];
+      CGAffineTransform t = CGAffineTransformMakeRotation(rads);
+      rotatedViewBox.transform = t;
+      CGSize rotatedSize = rotatedViewBox.frame.size;
+
+      UIGraphicsBeginImageContext(rotatedSize);
+        CGContextRef bitmap = UIGraphicsGetCurrentContext();
+        CGContextTranslateCTM(bitmap, rotatedSize.width/2, rotatedSize.height/2);
+        CGContextRotateCTM(bitmap, rads);
+        CGContextScaleCTM(bitmap, 1.0, -1.0);
+        CGContextDrawImage(bitmap, CGRectMake(-size.width / 2, -size.height / 2, size.width, size.height), image.CGImage);
+
+        image = UIGraphicsGetImageFromCurrentImageContext();
+      UIGraphicsEndImageContext();
+    } else if (options[@"flip"]) {
+      NSDictionary *flip = options[@"flip"];
+      UIImageView *tempImageView = [[UIImageView alloc] initWithImage:image];
+
+      UIGraphicsBeginImageContext(tempImageView.frame.size);
+        CGContextRef context = UIGraphicsGetCurrentContext();
+        CGAffineTransform transform;
+        if (flip[@"vertical"]) {
+          transform = CGAffineTransformMake(1, 0, 0, -1, 0, tempImageView.frame.size.height);
+          CGContextConcatCTM(context, transform);
+        } else if (flip[@"horizontal"]) {
+          transform = CGAffineTransformMake(-1, 0, 0, 1, tempImageView.frame.size.width, 0);
+          CGContextConcatCTM(context, transform);
+        }
+
+        [tempImageView.layer renderInContext:context];
+        image = UIGraphicsGetImageFromCurrentImageContext();
+      UIGraphicsEndImageContext();
+    } else if (options[@"crop"]) {
+      NSDictionary *cropData = options[@"crop"];
+      if (cropData[@"originX"] == nil || cropData[@"originY"] == nil || cropData[@"width"] == nil || cropData[@"height"]== nil) {
+        reject(@"E_INVALID_CROP_DATA", @"Invalid crop options has been passed. Please make sure the object contains originX, originY, width and height.", nil);
+        return;
+      }
+
+      float originX = [(NSNumber *)cropData[@"originX"] floatValue];
+      float originY = [(NSNumber *)cropData[@"originY"] floatValue];
+      float requestedWidth = [(NSNumber *)cropData[@"width"] floatValue];
+      float requestedHeight = [(NSNumber *)cropData[@"height"] floatValue];
+
+      if (originX > image.size.width || originY > image.size.height || requestedWidth > image.size.width || requestedHeight > image.size.height) {
+        reject(@"E_INVALID_CROP_DATA", @"Invalid crop options has been passed. Please make sure the requested crop rectangle is inside source image.", nil);
+        return;
+      }
+      CGRect cropDimensions = CGRectMake(originX, originY, requestedWidth, requestedHeight);
+      image = [ImageUtils cropImage:image toRect:cropDimensions];
+    }
+  }
+
+  float compressionValue = 1.0;
+  if (saveOptions[@"compress"] != nil) {
+    compressionValue = [(NSNumber *)saveOptions[@"compress"] floatValue];
+  }
+
+  NSData *imageData = nil;
+  NSString *format = saveOptions[@"format"];
+  NSString *extension;
+  if (format == nil) {
+    format = @"jpeg";
+  }
+  if ([format isEqualToString:@"jpeg"]) {
+    imageData = UIImageJPEGRepresentation(image, compressionValue);
+    extension = @".jpg";
+  } else if ([format isEqualToString:@"png"]) {
+    imageData = UIImagePNGRepresentation(image);
+    extension = @".png";
+  } else {
+    RCTLogWarn(@"Unsupported format: %@, using JPEG instead.", format);
+    imageData = UIImageJPEGRepresentation(image, compressionValue);
+    extension = @".jpg";
+  }
+
+
+  NSArray *paths = NSSearchPathForDirectoriesInDomains(NSCachesDirectory, NSUserDomainMask, YES);
+  NSString *directory = directory = [paths firstObject];
+  NSString *fileName = [[[NSUUID UUID] UUIDString] stringByAppendingString:extension];
+  NSString *newPath = [directory stringByAppendingPathComponent:fileName];
+
+  [imageData writeToFile:newPath atomically:YES];
+  NSURL *fileURL = [NSURL fileURLWithPath:newPath];
+  NSString *filePath = [fileURL absoluteString];
+  NSMutableDictionary *response = [[NSMutableDictionary alloc] init];
+  response[@"uri"] = filePath;
+  response[@"filename"] = fileName;
+  response[@"width"] = @(CGImageGetWidth(image.CGImage));
+  response[@"height"] = @(CGImageGetHeight(image.CGImage));
+  if (saveOptions[@"base64"] && [saveOptions[@"base64"] boolValue]) {
+   response[@"base64"] = [imageData base64EncodedStringWithOptions:0];
+  }
+
+  resolve(response);
+}
+
+@end