Сжать изображение без потери качества в android. Есть ли в android новая концепция или алгоритм?

Question

Я уже использую метод сжатия. Я хочу использовать любые новые техники, которые сжимают изображение еще меньшего размера без потери качества. Вот код с использованием, пожалуйста, скажите мне любую другую концепцию, которая лучше сжимает изображение, чем это, с точки зрения размера и качества. Заранее спасибо.

public String compress(int qualitypercentage, String imageUri, String FilePath, String FilenameWithExt, Uri contentUri) {
    String filePath = null;
    if(contentUri == null) {
        filePath = getRealPathFromURI(imageUri);
    } else {
        if (Build.VERSION.SDK_INT < 11)
            filePath = getRealPathFromURI_BelowAPI11(cntxt, contentUri);
            // SDK >= 11 && SDK < 19
        else if (Build.VERSION.SDK_INT <= 19)
            filePath = getRealPathFromURI_API11to18(cntxt, contentUri); 
            // SDK > 19 (Android 4.4)
        else
            filePath = getRealPathFromURI_API19(cntxt, contentUri);
    }           
    getRealPathFromURI(imageUri);
    Bitmap scaledBitmap = null;

    BitmapFactory.Options options = new BitmapFactory.Options();
    options.inJustDecodeBounds = true;
    options.inSampleSize = 1;
    // options.inPreferredConfig = Bitmap.Config.RGB_565;
    // options.inDither = true;
    //options.inTempStorage = new byte[16 * 1024];
    File imgFile = new File(filePath);

    Bitmap bmp = BitmapFactory.decodeFile(imgFile.getAbsolutePath(),options);

    int actualHeight = options.outHeight;
    int actualWidth = options.outWidth;

    //max Height and width values of the compressed image is taken as 816x612

    float maxHeight = 816.0f;
    float maxWidth = 612.0f;

    float imgRatio = actualWidth / actualHeight;
    float maxRatio = maxWidth / maxHeight;

    //width and height values are set maintaining the aspect ratio of the image

    if (actualHeight > maxHeight || actualWidth > maxWidth) {
        if (imgRatio < maxRatio) {
            imgRatio = maxHeight / actualHeight;
            actualWidth = (int) (imgRatio * actualWidth);
            actualHeight = (int) maxHeight;
        } else if (imgRatio > maxRatio) {
            imgRatio = maxWidth / actualWidth;
            actualHeight = (int) (imgRatio * actualHeight);
            actualWidth = (int) maxWidth;
        } else {
            actualHeight = (int) maxHeight;
            actualWidth = (int) maxWidth;
        }
    }

    //setting inSampleSize value allows to load a scaled down version of the original image

    options.inSampleSize = calculateInSampleSize(options, actualWidth, actualHeight);

    //inJustDecodeBounds set to false to load the actual bitmap
    options.inJustDecodeBounds = false;

    //options.inTempStorage = new byte[16 * 1024];
    //options.inPurgeable = true;

    try {
        //load the bitmap from its path
        bmp = BitmapFactory.decodeFile(filePath, options);
    } catch (OutOfMemoryError exception) {
        exception.printStackTrace();
    }
    try {
        scaledBitmap = Bitmap.createBitmap(actualWidth, actualHeight, Bitmap.Config.ARGB_8888);
    } 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));

    //check the rotation of the image and display it properly
    ExifInterface exif;
    try {
        exif = new ExifInterface(filePath);

        int orientation = exif.getAttributeInt(ExifInterface.TAG_ORIENTATION, 0);
        //Log.d("EXIF", "Exif: " + orientation);
        Matrix matrix = new Matrix();
        if (orientation == 6) {
            matrix.postRotate(90);
            //Log.d("EXIF", "Exif: " + orientation);
        } else if (orientation == 3) {
            matrix.postRotate(180);
            //Log.d("EXIF", "Exif: " + orientation);
        } else if (orientation == 8) {
            matrix.postRotate(270);
            //Log.d("EXIF", "Exif: " + orientation);
        }
        scaledBitmap = Bitmap.createBitmap(scaledBitmap, 0, 0, scaledBitmap.getWidth(), scaledBitmap.getHeight(), matrix, true);                     
    } catch (IOException e) {
        e.printStackTrace();
    }

    FileOutputStream out = null;
    String filename = MakeFilename(FilePath, FilenameWithExt);
    try {
        out = new FileOutputStream(filename);
        bmp.recycle();
        //write the compressed bitmap at the destination specified by filename.
        scaledBitmap.compress(Bitmap.CompressFormat.JPEG, qualitypercentage, out);
        int imageSizeAF=sizeOf(scaledBitmap);

        String Af_image=getByteSize((long) imageSizeAF);
    } catch (FileNotFoundException e) {
        e.printStackTrace();
    }
    return filename;
}

Пожалуйста, дайте мне знать о любых новейших методах.