在上传到firebase android之前压缩多个图像

Question

我正在开发应用程序，用户必须上传多个图像。现在我面临的问题是他们的规模。由于用户可以上传多个图像，这需要大量的时间来通过应用程序上传它们，因为它们太大了，用户不喜欢，也使我的应用程序和数据库沉重。你能指导我如何在上传多张图片到firebase之前压缩它们吗？

用于压缩图像的代码

  galleryResultLauncher = registerForActivityResult(new ActivityResultContracts.StartActivityForResult(), new ActivityResultCallback<ActivityResult>() {
        @Override
        public void onActivityResult(ActivityResult result) {


                if (result.getResultCode() == RESULT_OK && null != result.getData() ) {

                    if (result.getData().getClipData() != null) {

                        int countofImages = result.getData().getClipData().getItemCount();
                        //this part is to select multiple images
                        for (int i = 0; i < countofImages; i++) {

                            if (uri.size() < 11) {
                                Uri imageuri = result.getData().getClipData().getItemAt(i).getUri();


                              
                                imageList.add(new CustomModel(getfilename(imageuri), imageuri));
                            } else {
                                Toast.makeText(getContext(), "Can't select more than 11 images", Toast.LENGTH_SHORT).show();
                            }
                        }
                        //then notify the adapter
                        adapter.notifyDataSetChanged();
                        rentSell3Binding.totalphotos.setText("Photos (" + imageList.size() + ")");
                    }
                        //this part is to select single image
                        else
                            {

                            if (uri.size()<11) {
                                Uri imageuri = result.getData().getData();

                                //and add the code to arryalist
                         
                                imageList.add(new CustomModel(getfilename(imageuri), imageuri));

                            }else
                            {

                                Toast.makeText(getContext(), "Can't select more than 11 images", Toast.LENGTH_SHORT).show();

                            }

                        //notify the adapter
                        adapter.notifyDataSetChanged();
                        rentSell3Binding.totalphotos.setText("Photos (" + imageList.size() + ")");
                    }
                }else
                {
                    Toast.makeText(getContext(), "You haven't selected any images", Toast.LENGTH_SHORT).show();

                }
            }


    });

模特班

public class CustomModel {

String imageName;
Uri imageURI;


public CustomModel(String imageName, Uri imageURI) {
    this.imageName = imageName;
    this.imageURI = imageURI;
}

public String getImageName() {
    return imageName;
}

public void setImageName(String imageName) {
    this.imageName = imageName;
}

public Uri getImageURI() {
    return imageURI;
}

public void setImageURI(Uri imageURI) {
    this.imageURI = imageURI;
}

}

引发异常

null pointer exception on the line File file = new File(SiliCompressor.with(getContext()).compress(FileUtils.getPath(getContext(), imageuri), new File(getContext().getCacheDir(), "temp")));

Answer 1

是的，您可以通过以下函数压缩图像文件

@Throws(IOException::class)
fun File.compressImage(
    reqWidth: Float,
    reqHeight: Float,
    compressFormat: Bitmap.CompressFormat,
    quality: Int,
    destinationPath: String
): File {
    var fileOutputStream: FileOutputStream? = null
    val file = File(destinationPath).parentFile ?: return File(destinationPath)

    if (!file.exists()) {
        file.mkdirs()
    }
    try {
        fileOutputStream = FileOutputStream(destinationPath)
        // write the compressed bitmap at the destination specified by destinationPath.
        decodeSampledBitmapFromFile(this, reqWidth, reqHeight)?.compress(
            compressFormat,
            quality,
            fileOutputStream
        )
    } finally {
        if (fileOutputStream != null) {
            fileOutputStream.flush()
            fileOutputStream.close()
        }
    }

    return File(destinationPath)
}

@Throws(IOException::class)
private fun decodeSampledBitmapFromFile(
    imageFile: File,
    reqWidth: Float,
    reqHeight: Float
): Bitmap? {
    // First decode with inJustDecodeBounds=true to check dimensions

    val options = BitmapFactory.Options()
    options.inJustDecodeBounds = true
    var bmp: Bitmap? = BitmapFactory.decodeFile(imageFile.absolutePath, options)

    var actualHeight = options.outHeight
    var actualWidth = options.outWidth

    var imgRatio = actualWidth.toFloat() / actualHeight.toFloat()
    val maxRatio = reqWidth / reqHeight

    if (actualHeight > reqHeight || actualWidth > reqWidth) {
        // If Height is greater
        when {
            imgRatio < maxRatio -> {
                imgRatio = reqHeight / actualHeight
                actualWidth = (imgRatio * actualWidth).toInt()
                actualHeight = reqHeight.toInt()
            } // If Width is greater
            imgRatio > maxRatio -> {
                imgRatio = reqWidth / actualWidth
                actualHeight = (imgRatio * actualHeight).toInt()
                actualWidth = reqWidth.toInt()
            }
            else -> {
                actualHeight = reqHeight.toInt()
                actualWidth = reqWidth.toInt()
            }
        }
    }

    // Calculate inSampleSize
    options.inSampleSize = calculateInSampleSize(options, actualWidth, actualHeight)
    options.inJustDecodeBounds = false

    if (bmp != null && canUseForInBitmap(bmp, options)) {
        // inBitmap only works with mutable bitmaps, so force the decoder to
        // return mutable bitmaps.
        options.inMutable = true
        options.inBitmap = bmp
    }
    options.inTempStorage = ByteArray(16 * 1024)

    try {
        bmp = BitmapFactory.decodeFile(imageFile.absolutePath, options)
    } catch (exception: OutOfMemoryError) {
        exception.printStackTrace()
    }

    var scaledBitmap: Bitmap? = null
    try {
        scaledBitmap = Bitmap.createBitmap(actualWidth, actualHeight, Bitmap.Config.ARGB_8888)
    } catch (exception: OutOfMemoryError) {
        exception.printStackTrace()
    }

    val ratioX = actualWidth / options.outWidth.toFloat()
    val ratioY = actualHeight / options.outHeight.toFloat()
    val middleX = actualWidth / 2.0f
    val middleY = actualHeight / 2.0f

    val scaleMatrix = Matrix()
    scaleMatrix.setScale(ratioX, ratioY, middleX, middleY)

    val canvas = Canvas(scaledBitmap!!)
    canvas.setMatrix(scaleMatrix)
    canvas.drawBitmap(
        bmp!!, middleX - bmp.width / 2,
        middleY - bmp.height / 2, Paint(Paint.FILTER_BITMAP_FLAG)
    )
    bmp.recycle()
    val exif: ExifInterface
    try {
        exif = ExifInterface(imageFile.absolutePath)
        val orientation = exif.getAttributeInt(ExifInterface.TAG_ORIENTATION, 0)
        val matrix = Matrix()
        if (orientation == 6) {
            matrix.postRotate(90f)
        } else if (orientation == 3) {
            matrix.postRotate(180f)
        } else if (orientation == 8) {
            matrix.postRotate(270f)
        }
        scaledBitmap = Bitmap.createBitmap(
            scaledBitmap, 0, 0, scaledBitmap.width,
            scaledBitmap.height, matrix, true
        )
    } catch (e: IOException) {
        e.printStackTrace()
    }

    return scaledBitmap
}

private fun calculateInSampleSize(
    options: BitmapFactory.Options,
    reqWidth: Int,
    reqHeight: Int
): Int {
    // Raw height and width of image
    val height = options.outHeight
    val width = options.outWidth
    var inSampleSize = 1

    if (height > reqHeight || width > reqWidth) {
        inSampleSize *= 2
        val halfHeight = height / 2
        val halfWidth = width / 2

        // Calculate the largest inSampleSize value that is a power of 2 and keeps both
        // height and width larger than the requested height and width.
        while (halfHeight / inSampleSize >= reqHeight && halfWidth / inSampleSize >= reqWidth) {
            inSampleSize *= 2
        }
    }

    return inSampleSize
}

/**
 * Ref: https://developer.android.com/topic/performance/graphics/manage-memory#kotlin
 */
private fun canUseForInBitmap(candidate: Bitmap, targetOptions: BitmapFactory.Options): Boolean {
    return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
        // From Android 4.4 (KitKat) onward we can re-use if the byte size of
        // the new bitmap is smaller than the reusable bitmap candidate
        // allocation byte count.
        val width: Int = targetOptions.outWidth / targetOptions.inSampleSize
        val height: Int = targetOptions.outHeight / targetOptions.inSampleSize
        val byteCount: Int = width * height * getBytesPerPixel(candidate.config)
        byteCount <= candidate.allocationByteCount
    } else {
        // On earlier versions, the dimensions must match exactly and the inSampleSize must be 1
        candidate.width == targetOptions.outWidth &&
                candidate.height == targetOptions.outHeight &&
                targetOptions.inSampleSize == 1
    }
}

/**
 * A helper function to return the byte usage per pixel of a bitmap based on its configuration.
 */
private fun getBytesPerPixel(config: Bitmap.Config): Int {
    return when (config) {
        Bitmap.Config.ARGB_8888 -> 4
        Bitmap.Config.RGB_565, Bitmap.Config.ARGB_4444 -> 2
        Bitmap.Config.ALPHA_8 -> 1
        else -> 1
    }
}

@Throws(IOException::class)
fun Context.createImageFile(): File {
    // Create an image file name
    val storageDir: File? = getExternalFilesDir(Environment.DIRECTORY_PICTURES)
    return File.createTempFile(
        "JPEG_${System.currentTimeMillis()}_", /* prefix */
        ".jpg", /* suffix */
        storageDir /* directory */
    )
}

并简单地调用以下方法来创建压缩图像文件。这里的文件是你的图像文件

file.compressImage(
                    1024f,
                    1024f,
                    Bitmap.CompressFormat.JPEG,
                    70,
                    context.createImageFile().path
                )