react-native-compressor 1.7.1 → 1.8.0

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

@@ -1,220 +0,0 @@
-package com.reactnativecompressor;
-
-import androidx.annotation.NonNull;
-
-import com.facebook.react.bridge.Promise;
-import com.facebook.react.bridge.ReactApplicationContext;
-import com.facebook.react.bridge.ReactMethod;
-
-import androidx.annotation.RequiresApi;
-
-import com.facebook.react.bridge.Arguments;
-import com.facebook.react.bridge.ReactContext;
-import com.facebook.react.bridge.ReadableMap;
-import com.facebook.react.bridge.WritableMap;
-import com.reactnativecompressor.Image.ImageCompressor;
-import com.reactnativecompressor.Image.utils.ImageCompressorOptions;
-import com.reactnativecompressor.Utils.MediaCache;
-import com.reactnativecompressor.Utils.Utils;
-import com.reactnativecompressor.Video.VideoCompressorHelper;
-import com.reactnativecompressor.CompressorSpec;
-import static com.reactnativecompressor.Utils.Utils.generateCacheFilePath;
-
-import android.content.ContentResolver;
-import android.content.res.AssetFileDescriptor;
-import android.database.Cursor;
-import android.media.MediaMetadataRetriever;
-import android.net.Uri;
-import android.os.Build;
-import android.provider.OpenableColumns;
-import android.util.Log;
-
-import com.reactnativecompressor.Audio.AudioCompressor;
-
-import java.io.File;
-import java.io.FileNotFoundException;
-
-public class CompressorModule extends CompressorSpec {
-  public static final String NAME = "Compressor";
-  private final ReactApplicationContext reactContext;
-
-  public CompressorModule(ReactApplicationContext context) {
-    super(context);
-    this.reactContext = context;
-  }
-
-  @Override
-  @NonNull
-  public String getName() {
-    return NAME;
-  }
-
-  //Image
-  @ReactMethod
-  public void image_compress(
-    String imagePath,
-    ReadableMap optionMap,
-    Promise promise) {
-    try {
-      final ImageCompressorOptions options = ImageCompressorOptions.fromMap(optionMap);
-      imagePath=Utils.getRealPath(imagePath,reactContext,options.uuid);
-
-
-      if(options.compressionMethod==ImageCompressorOptions.CompressionMethod.auto)
-      {
-        String returnableResult=ImageCompressor.autoCompressImage(imagePath,options,reactContext);
-        promise.resolve(returnableResult);
-      }
-      else
-      {
-        String returnableResult=ImageCompressor.manualCompressImage(imagePath,options,reactContext);
-        promise.resolve(returnableResult);
-      }
-      MediaCache.removeCompletedImagePath(imagePath);
-    } catch (Exception ex) {
-      promise.reject(ex);
-    }
-  }
-
-  @ReactMethod
-  @RequiresApi(api = Build.VERSION_CODES.JELLY_BEAN_MR2)
-  public void compress_audio(
-    String fileUrl,
-    ReadableMap optionMap,
-    Promise promise) {
-    try{
-      final VideoCompressorHelper options = VideoCompressorHelper.fromMap(optionMap);
-      Uri uri= Uri.parse(fileUrl);
-      String srcPath = uri.getPath();
-      String destinationPath = generateCacheFilePath("mp3", reactContext);
-
-      MediaMetadataRetriever metaRetriever = new MediaMetadataRetriever();
-      metaRetriever.setDataSource(srcPath);
-
-      float bitrate = options.bitrate;
-      Log.d("nomi onStart", destinationPath+"onProgress: "+bitrate);
-      new AudioCompressor().CompressAudio(srcPath, destinationPath, (int) bitrate*1000);
-
-    } catch (Exception ex) {
-      promise.reject(ex);
-    }
-  }
-
-
-  //General
-  @ReactMethod
-  public void generateFilePath(String extension, Promise promise) {
-    try {
-      final String outputUri =generateCacheFilePath(extension,reactContext);
-      promise.resolve(outputUri);
-    } catch (Exception e) {
-      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 creationTime = metaRetriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_DATE);
-      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);
-      params.putString("creationTime", String.valueOf(creationTime));
-
-      promise.resolve(params);
-    } catch (Exception e) {
-      promise.reject(e);
-    }
-  }
-  @ReactMethod
-  public void getFileSize(String filePath, Promise promise)
-  {
-    if(filePath.startsWith("http://")||filePath.startsWith("https://"))
-    {
-      promise.resolve(Utils.getFileSizeFromURL(filePath));
-    }
-    else
-    {
-      filePath=Utils.getRealPath(filePath,reactContext);
-      Uri uri= Uri.parse(filePath);
-      ContentResolver contentResolver = reactContext.getContentResolver();
-      long fileSize = getLength(uri, contentResolver);
-      if (fileSize >= 0) {
-        promise.resolve(String.valueOf(fileSize));
-      } else {
-        promise.resolve("");
-      }
-    }
-  }
-
-  @ReactMethod
-  public void addListener(String eventName) {
-
-  }
-
-  @ReactMethod
-  public void removeListeners(double count) {
-
-  }
-
-  public static long getLength(Uri uri, ContentResolver contentResolver) {
-    AssetFileDescriptor assetFileDescriptor = null;
-    try {
-      assetFileDescriptor = contentResolver.openAssetFileDescriptor(uri, "r");
-    } catch (FileNotFoundException e) {
-      // Do nothing
-    }
-
-    long length = (assetFileDescriptor != null) ? assetFileDescriptor.getLength() : -1L;
-    if (length != -1L) {
-      return length;
-    }
-
-    if (ContentResolver.SCHEME_CONTENT.equals(uri.getScheme())) {
-      Cursor cursor = contentResolver.query(uri, new String[]{OpenableColumns.SIZE}, null, null, null);
-      if (cursor != null) {
-        try {
-          int sizeIndex = cursor.getColumnIndex(OpenableColumns.SIZE);
-          if (sizeIndex != -1 && cursor.moveToFirst()) {
-            try {
-              return cursor.getLong(sizeIndex);
-            } catch (Throwable ignored) {
-              return -1L;
-            }
-          }
-        } finally {
-          cursor.close();
-        }
-      }
-      return -1L;
-    } else {
-      return -1L;
-    }
-  }
-
-}

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

@@ -1,58 +0,0 @@
-package com.reactnativecompressor;
-
-import androidx.annotation.Nullable;
-
-import com.facebook.react.bridge.NativeModule;
-import com.facebook.react.bridge.ReactApplicationContext;
-import com.facebook.react.module.model.ReactModuleInfo;
-import com.facebook.react.module.model.ReactModuleInfoProvider;
-import com.facebook.react.TurboReactPackage;
-import java.util.HashMap;
-import java.util.Map;
-import com.reactnativecompressor.Video.VideoModule;
-
-public class CompressorPackage extends TurboReactPackage {
-
-  @Nullable
-  @Override
-  public NativeModule getModule(String name, ReactApplicationContext reactContext) {
-    if (name.equals(CompressorModule.NAME)) {
-      return new CompressorModule(reactContext);
-    } else if (name.equals(VideoModule.NAME)) {
-      return new VideoModule(reactContext);
-    } else {
-      return null;
-    }
-  }
-
-  @Override
-  public ReactModuleInfoProvider getReactModuleInfoProvider() {
-    return () -> {
-      final Map<String, ReactModuleInfo> moduleInfos = new HashMap<>();
-      boolean isTurboModule = BuildConfig.IS_NEW_ARCHITECTURE_ENABLED;
-      moduleInfos.put(
-              CompressorModule.NAME,
-              new ReactModuleInfo(
-                      CompressorModule.NAME,
-                      CompressorModule.NAME,
-                      false, // canOverrideExistingModule
-                      false, // needsEagerInit
-                      true, // hasConstants
-                      false, // isCxxModule
-                      isTurboModule // isTurboModule
-      ));
-      moduleInfos.put(
-        VideoModule.NAME,
-        new ReactModuleInfo(
-          VideoModule.NAME,
-          VideoModule.NAME,
-          false, // canOverrideExistingModule
-          false, // needsEagerInit
-          true, // hasConstants
-          false, // isCxxModule
-          isTurboModule // isTurboModule
-        ));
-      return moduleInfos;
-    };
-  }
-}

package/android/src/main/java/com/reactnativecompressor/Image/ImageCompressor.java

@@ -1,257 +0,0 @@
-package com.reactnativecompressor.Image;
-
-import android.graphics.Bitmap;
-import android.graphics.BitmapFactory;
-import android.graphics.Canvas;
-import android.graphics.Matrix;
-import android.graphics.Paint;
-import android.media.ExifInterface;
-import android.net.Uri;
-import android.util.Base64;
-
-import com.facebook.react.bridge.ReactApplicationContext;
-import com.reactnativecompressor.Image.utils.ImageCompressorOptions;
-import com.reactnativecompressor.Image.utils.ImageSize;
-
-import java.io.ByteArrayOutputStream;
-import java.io.File;
-import java.io.FileNotFoundException;
-import java.io.FileOutputStream;
-import java.io.IOException;
-import java.net.MalformedURLException;
-
-import static com.reactnativecompressor.Utils.Utils.generateCacheFilePath;
-
-
-public class ImageCompressor {
-
-  public static String getRNFileUrl(String filePath) {
-    File returnAbleFile= new File(filePath);
-    try {
-      filePath = returnAbleFile.toURL().toString();
-    } catch (MalformedURLException e) {
-      e.printStackTrace();
-    }
-    return filePath;
-  }
-
-  public static ImageSize findActualSize(Bitmap image, int maxWidth, int maxHeight) {
-        final float width = (float) image.getWidth();
-        final float height = (float) image.getHeight();
-
-        if (width > height) {
-            final int newHeight = Math.round(height / (width / maxWidth));
-            final float scale = newHeight / height;
-
-            return new ImageSize(maxWidth, newHeight, scale);
-        }
-
-        final int newWidth = Math.round(width / (height / maxHeight));
-        final float scale = newWidth / width;
-
-        return new ImageSize(newWidth, maxHeight, scale);
-    }
-
-    public static Bitmap decodeImage(String value) {
-        final byte[] data = Base64.decode(value, Base64.DEFAULT);
-        return BitmapFactory.decodeByteArray(data, 0, data.length);
-    }
-
-    public static Bitmap loadImage(String value) {
-      Uri uri= Uri.parse(value);
-      String filePath = uri.getPath();
-      Bitmap bitmap = BitmapFactory.decodeFile(filePath);
-        return bitmap;
-    }
-
-
-
-  public static String encodeImage(ByteArrayOutputStream imageDataByteArrayOutputStream, Boolean isBase64,String outputExtension, ReactApplicationContext reactContext) {
-    if(isBase64)
-    {
-      byte[] imageData=imageDataByteArrayOutputStream.toByteArray();
-      return Base64.encodeToString(imageData, Base64.DEFAULT);
-    }
-    else
-    {
-      String outputUri=generateCacheFilePath(outputExtension,reactContext);
-      try {
-        FileOutputStream fos=new FileOutputStream(outputUri);
-        imageDataByteArrayOutputStream.writeTo(fos);
-        return getRNFileUrl(outputUri);
-      } catch (Exception e) {
-        e.printStackTrace();
-      }
-    }
-  return  "";
-    }
-
-  public static Bitmap resize(Bitmap image, int maxWidth, int maxHeight) {
-        final ImageSize size = findActualSize(image, maxWidth, maxHeight);
-
-        final Bitmap scaledImage = Bitmap.createBitmap(size.width, size.height, image.getConfig());
-        final Matrix scaleMatrix = new Matrix();
-        final Canvas canvas = new Canvas(scaledImage);
-        final Paint paint = new Paint(Paint.FILTER_BITMAP_FLAG);
-
-        scaleMatrix.setScale(size.scale, size.scale, 0 ,0);
-
-        paint.setDither(true);
-        paint.setAntiAlias(true);
-        paint.setFilterBitmap(true);
-
-        canvas.drawBitmap(image, scaleMatrix, paint);
-
-        return scaledImage;
-    }
-
-  public static ByteArrayOutputStream compress(Bitmap image, ImageCompressorOptions.OutputType output, float quality) {
-        final ByteArrayOutputStream stream = new ByteArrayOutputStream();
-        final Bitmap.CompressFormat format = output == ImageCompressorOptions.OutputType.jpg
-                ? Bitmap.CompressFormat.JPEG
-                : Bitmap.CompressFormat.PNG;
-
-        image.compress(format, Math.round(100 * quality), stream);
-        return stream;
-    }
-
-  public static String manualCompressImage(String imagePath,ImageCompressorOptions options, ReactApplicationContext reactContext) {
-    final Bitmap image = options.input == ImageCompressorOptions.InputType.base64
-      ? ImageCompressor.decodeImage(imagePath)
-      : ImageCompressor.loadImage(imagePath);
-
-    final Bitmap resizedImage = ImageCompressor.resize(image, options.maxWidth, options.maxHeight);
-    final ByteArrayOutputStream imageDataByteArrayOutputStream = ImageCompressor.compress(resizedImage, options.output, options.quality);
-    Boolean isBase64=options.returnableOutputType==ImageCompressorOptions.ReturnableOutputType.base64;
-
-    String returnableResult = ImageCompressor.encodeImage(imageDataByteArrayOutputStream,isBase64,options.output.toString(),reactContext);
-    return  returnableResult;
-  }
-
-
-  public static String autoCompressImage(String imagePath,ImageCompressorOptions compressorOptions, ReactApplicationContext reactContext) {
-    String outputExtension=compressorOptions.output.toString();
-    float autoCompressMaxHeight = compressorOptions.maxHeight;
-    float autoCompressMaxWidth = compressorOptions.maxWidth;
-    Boolean isBase64=compressorOptions.returnableOutputType==ImageCompressorOptions.ReturnableOutputType.base64;
-
-    Uri uri= Uri.parse(imagePath);
-    imagePath = uri.getPath();
-    Bitmap scaledBitmap = null;
-
-    BitmapFactory.Options options = new BitmapFactory.Options();
-    options.inJustDecodeBounds = true;
-    Bitmap bmp = BitmapFactory.decodeFile(imagePath, options);
-
-    int actualHeight = options.outHeight;
-    int actualWidth = options.outWidth;
-
-    float imgRatio = (float) actualWidth / (float) actualHeight;
-    float maxRatio = autoCompressMaxWidth / autoCompressMaxHeight;
-
-    if (actualHeight > autoCompressMaxHeight || actualWidth > autoCompressMaxWidth) {
-      if (imgRatio < maxRatio) {
-        imgRatio = autoCompressMaxHeight / actualHeight;
-        actualWidth = (int) (imgRatio * actualWidth);
-        actualHeight = (int) autoCompressMaxHeight;
-      } else if (imgRatio > maxRatio) {
-        imgRatio = autoCompressMaxWidth / actualWidth;
-        actualHeight = (int) (imgRatio * actualHeight);
-        actualWidth = (int) autoCompressMaxWidth;
-      } else {
-        actualHeight = (int) autoCompressMaxHeight;
-        actualWidth = (int) autoCompressMaxWidth;
-
-      }
-    }
-
-    options.inSampleSize = calculateInSampleSize(options, actualWidth, actualHeight);
-    options.inJustDecodeBounds = false;
-    options.inDither = false;
-    options.inPurgeable = true;
-    options.inInputShareable = true;
-    options.inTempStorage = new byte[16 * 1024];
-
-    try {
-      bmp = BitmapFactory.decodeFile(imagePath, options);
-    } catch (OutOfMemoryError exception) {
-      exception.printStackTrace();
-
-    }
-    try {
-      scaledBitmap = Bitmap.createBitmap(actualWidth, actualHeight, Bitmap.Config.RGB_565);
-    } catch (OutOfMemoryError exception) {
-      exception.printStackTrace();
-    }
-
-    float ratioX = actualWidth / (float) options.outWidth;
-    float ratioY = actualHeight / (float) options.outHeight;
-    float middleX = actualWidth / 2.0f;
-    float middleY = actualHeight / 2.0f;
-
-    Matrix scaleMatrix = new Matrix();
-    scaleMatrix.setScale(ratioX, ratioY, middleX, middleY);
-
-    Canvas canvas = new Canvas(scaledBitmap);
-    canvas.setMatrix(scaleMatrix);
-    canvas.drawBitmap(bmp, middleX - bmp.getWidth() / 2, middleY - bmp.getHeight() / 2, new Paint(Paint.FILTER_BITMAP_FLAG));
-
-    if(bmp!=null)
-    {
-      bmp.recycle();
-    }
-
-    scaledBitmap = correctImageOrientation(scaledBitmap, imagePath);
-
-    final ByteArrayOutputStream imageDataByteArrayOutputStream = ImageCompressor.compress(scaledBitmap, compressorOptions.output, compressorOptions.quality);
-    String returnableResult = ImageCompressor.encodeImage(imageDataByteArrayOutputStream,isBase64,compressorOptions.output.toString(),reactContext);
-    return  returnableResult;
-  }
-
-  public static int calculateInSampleSize(BitmapFactory.Options options, int reqWidth, int reqHeight) {
-    final int height = options.outHeight;
-    final int width = options.outWidth;
-    int inSampleSize = 1;
-
-    if (height > reqHeight || width > reqWidth) {
-      final int heightRatio = Math.round((float) height / (float) reqHeight);
-      final int widthRatio = Math.round((float) width / (float) reqWidth);
-      inSampleSize = heightRatio < widthRatio ? heightRatio : widthRatio;
-    }
-    final float totalPixels = width * height;
-    final float totalReqPixelsCap = reqWidth * reqHeight * 2;
-
-    while (totalPixels / (inSampleSize * inSampleSize) > totalReqPixelsCap) {
-      inSampleSize++;
-    }
-
-    return inSampleSize;
-  }
-
-  public static Bitmap correctImageOrientation(Bitmap bitmap, String imagePath) {
-    try {
-      ExifInterface exif = new ExifInterface(imagePath);
-      int orientation = exif.getAttributeInt(ExifInterface.TAG_ORIENTATION, ExifInterface.ORIENTATION_NORMAL);
-      Matrix matrix = new Matrix();
-
-      switch (orientation) {
-        case ExifInterface.ORIENTATION_ROTATE_90:
-          matrix.postRotate(90);
-          break;
-        case ExifInterface.ORIENTATION_ROTATE_180:
-          matrix.postRotate(180);
-          break;
-        case ExifInterface.ORIENTATION_ROTATE_270:
-          matrix.postRotate(270);
-          break;
-        default:
-          return bitmap; // No rotation needed
-      }
-
-      return Bitmap.createBitmap(bitmap, 0, 0, bitmap.getWidth(), bitmap.getHeight(), matrix, true);
-    } catch (IOException e) {
-      e.printStackTrace();
-      return bitmap; // Return original bitmap if an error occurs
-    }
-  }
-}

package/android/src/main/java/com/reactnativecompressor/Image/utils/ImageCompressorOptions.java

@@ -1,69 +0,0 @@
-package com.reactnativecompressor.Image.utils;
-
-import com.facebook.react.bridge.ReadableMap;
-import com.facebook.react.bridge.ReadableMapKeySetIterator;
-
-public class ImageCompressorOptions {
-    public static ImageCompressorOptions fromMap(ReadableMap map) {
-        final ImageCompressorOptions options = new ImageCompressorOptions();
-        final ReadableMapKeySetIterator iterator = map.keySetIterator();
-
-        while (iterator.hasNextKey()) {
-            final String key = iterator.nextKey();
-
-            switch (key) {
-                case "compressionMethod":
-                     options.compressionMethod = CompressionMethod.valueOf(map.getString(key));
-                      break;
-                case "maxWidth":
-                    options.maxWidth = map.getInt(key);
-                    break;
-                case "maxHeight":
-                    options.maxHeight = map.getInt(key);
-                    break;
-                case "quality":
-                    options.quality = (float) map.getDouble(key);
-                    break;
-                case "input":
-                    options.input = InputType.valueOf(map.getString(key));
-                    break;
-                case "output":
-                    options.output = OutputType.valueOf(map.getString(key));
-                    break;
-              case "returnableOutputType":
-                options.returnableOutputType = ReturnableOutputType.valueOf(map.getString(key));
-                break;
-              case "uuid":
-                options.uuid = map.getString(key);
-                break;
-            }
-        }
-
-        return options;
-    }
-
-    public enum InputType {
-        base64, uri
-    }
-
-    public enum OutputType {
-        png, jpg
-    }
-
-  public enum ReturnableOutputType {
-    base64, uri
-  }
-
-  public enum CompressionMethod {
-    auto, manual
-  }
-
-    public CompressionMethod compressionMethod = CompressionMethod.auto;
-    public int maxWidth = 1280;
-    public int maxHeight = 1280;
-    public float quality = 0.8f;
-    public InputType input = InputType.uri;
-    public OutputType output = OutputType.jpg;
-    public String uuid = "";
-    public ReturnableOutputType returnableOutputType = ReturnableOutputType.uri;
-}

package/android/src/main/java/com/reactnativecompressor/Image/utils/ImageSize.java

@@ -1,13 +0,0 @@
-package com.reactnativecompressor.Image.utils;
-
-public class ImageSize {
-    public int width;
-    public int height;
-    public float scale;
-
-    public ImageSize(int width, int height, float scale) {
-        this.width = width;
-        this.height = height;
-        this.scale = scale;
-    }
-}

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

@@ -1,39 +0,0 @@
-package com.reactnativecompressor.Utils.FileUplaoder;
-
-import com.facebook.react.bridge.ReadableMap;
-import com.facebook.react.bridge.ReadableMapKeySetIterator;
-
-public class FileUploadHelper {
-  public static FileUploadHelper fromMap(ReadableMap map) {
-    final FileUploadHelper options = new FileUploadHelper();
-    final ReadableMapKeySetIterator iterator = map.keySetIterator();
-
-    while (iterator.hasNextKey()) {
-      final String key = iterator.nextKey();
-
-      switch (key) {
-        case "uuid":
-          options.uuid = map.getString(key);
-          break;
-
-        case "method":
-          options.method = map.getString(key);
-          break;
-
-        case "headers":
-          options.headers = map.getMap(key);
-          break;
-
-        case "url":
-          options.url = map.getString(key);
-          break;
-
-      }
-    }
-    return options;
-  }
-  public String uuid;
-  public String method;
-  public ReadableMap headers;
-  public String url;
-}