Bitmap源码学习：在Android中如何压缩一个Bitmap

public static Bitmap createScaledBitmap(@NonNull Bitmap src, int dstWidth, int dstHeight,
            boolean filter) {
        // 创建一个矩阵对象，用于缩放操作
        Matrix m = new Matrix();

        // 获取原始图片的宽度和高度
        final int width = src.getWidth();
        final int height = src.getHeight();

        // 如果原始图片的宽度或高度与目标宽度或高度不一致
        if (width != dstWidth || height != dstHeight) {
            // 计算宽度和高度的缩放比例
            final float sx = dstWidth / (float) width;
            final float sy = dstHeight / (float) height;
            // 设置矩阵对象的缩放比例
            m.setScale(sx, sy);
        }

        // 根据矩阵对象进行缩放操作，并返回缩放后的 Bitmap 对象
        return Bitmap.createBitmap(src, 0, 0, width, height, m, filter);
    }

public static Bitmap createBitmap(@NonNull Bitmap source, int x, int y, int width, int height,
            @Nullable Matrix m, boolean filter) {

        // 检查坐标值是否为非负数
        checkXYSign(x, y);
        // 检查宽度和高度是否为正数
        checkWidthHeight(width, height);
        // 检查x、y和width、height的和是否小于等于原始图片的宽度和高度
        if (x + width > source.getWidth()) {
            throw new IllegalArgumentException("x + width must be <= bitmap.width()");
        }
        if (y + height > source.getHeight()) {
            throw new IllegalArgumentException("y + height must be <= bitmap.height()");
        }
        // 检查源 Bitmap 是否已被回收
        if (source.isRecycled()) {
            throw new IllegalArgumentException("cannot use a recycled source in createBitmap");
        }

        // 检查是否可以直接返回原始 Bitmap（无需进行任何操作）
        if (!source.isMutable() && x == 0 && y == 0 && width == source.getWidth() &&
                height == source.getHeight() && (m == null || m.isIdentity())) {
            return source;
        }

        // 检查是否为硬件加速的 Bitmap
        boolean isHardware = source.getConfig() == Config.HARDWARE;
        if (isHardware) {
            source.noteHardwareBitmapSlowCall();
            source = nativeCopyPreserveInternalConfig(source.mNativePtr);
        }

        int neww = width;
        int newh = height;
        Bitmap bitmap;
        Paint paint;

        // 创建源矩形和目标矩形
        Rect srcR = new Rect(x, y, x + width, y + height);
        RectF dstR = new RectF(0, 0, width, height);
        RectF deviceR = new RectF();

        // 设置新的 Bitmap 的配置
        Config newConfig = Config.ARGB_8888;
        final Config config = source.getConfig();
        if (config != null) {
            switch (config) {
                case RGB_565:
                    newConfig = Config.RGB_565;
                    break;
                case ALPHA_8:
                    newConfig = Config.ALPHA_8;
                    break;
                case RGBA_F16:
                    newConfig = Config.RGBA_F16;
                    break;
                case ARGB_4444:
                case ARGB_8888:
                default:
                    newConfig = Config.ARGB_8888;
                    break;
            }
        }

        ColorSpace cs = source.getColorSpace();

        if (m == null || m.isIdentity()) {
            // 不需要变换，直接创建新的 Bitmap
            bitmap = createBitmap(null, neww, newh, newConfig, source.hasAlpha(), cs);
            paint = null; // 不需要绘制操作
        } else {
            final boolean transformed = !m.rectStaysRect();

            // 将目标矩形通过矩阵变换得到设备矩形
            m.mapRect(deviceR, dstR);

            neww = Math.round(deviceR.width());
            newh = Math.round(deviceR.height());

            Config transformedConfig = newConfig;
            if (transformed) {
                if (transformedConfig != Config.ARGB_8888 && transformedConfig != Config.RGBA_F16) {
                    transformedConfig = Config.ARGB_8888;
                    if (cs == null) {
                        cs = Color

Space.get(ColorSpace.Named.SRGB);
                    }
                }
            }

            // 根据变换后的宽度、高度和配置创建新的 Bitmap
            bitmap = createBitmap(null, neww, newh, transformedConfig,
                    transformed || source.hasAlpha(), cs);

            // 创建画笔对象，并设置滤波器和抗锯齿
            paint = new Paint();
            paint.setFilterBitmap(filter);
            if (transformed) {
                paint.setAntiAlias(true);
            }
        }

        // 设置新的 Bitmap 的一些属性
        bitmap.mDensity = source.mDensity;
        bitmap.setHasAlpha(source.hasAlpha());
        bitmap.setPremultiplied(source.mRequestPremultiplied);

        // 创建画布对象，并进行画布的平移和矩阵的变换
        Canvas canvas = new Canvas(bitmap);
        canvas.translate(-deviceR.left, -deviceR.top);
        canvas.concat(m);
        // 在画布上绘制源 Bitmap
        canvas.drawBitmap(source, srcR, dstR, paint);
        canvas.setBitmap(null);

        // 如果是硬件加速的 Bitmap，则复制一个硬件加速的 Bitmap 返回
        if (isHardware) {
            return bitmap.copy(Config.HARDWARE, false);
        }

        return bitmap;
    }