Android—Bitmap解析与应用

项目地址

https://github.com/ListerChen/BitmapProject

一、Bitmap基本介绍

Bitmap也称为位图，是图片在内存中的表现形式，任何图片(JPEG, PNG, WEBP…)加载到内存后都是一个Bitmap对象。Bitmap实际是像素点的集合，假设它的宽高为width和height，那么该Bitmap就包含width*height个像素，它在内存中占用的内存就是(width*height*单个像素内存)。

为了减小图片在磁盘上所占的空间，将Bitmap保存到磁盘上时会进行压缩，图片的文件格式实际代表的是不同的压缩方式与压缩率，而将磁盘上的文件加载到内存中时就要进行解压缩。

1.1 图片格式介绍

常见的静态图片格式为JPEG、PNG和WEBP，它们有着不同的压缩方式，保存到本地后所占用的空间大小也不一样。

1. JPEG是一种有损压缩格式，以24位颜色压缩存储单个位图，但是不支持透明度。使用JPEG进行压缩时需要选择适当的压缩率，避免图片质量太差。
2. PNG是一种无损压缩格式，支持所有的颜色，由于是无损压缩，PNG一般用于APP图标这类对线条或者清晰度有要求的图片。由于PNG所占空间较大，目前一般将PNG转为WEBP使用。
3. WEBP支持无损压缩和有损压缩，并且他的无损压缩率优于PNG，有损压缩率优于JPEG，同时它支持所有颜色，并支持多帧动画，唯一的缺点是压缩效率不如JPEG和PNG。

1.2 Bitmap色深

Bitmap的本质就是像素点的集合，它通过描述每个像素的ARGB信息来形成整张图片，其中A表示透明度通道，RGB表示红绿蓝3种颜色通道，每个通道的值都在0-255之间，因此8bit可以完整地表示1个通道，那么4x8=32bit可以表示一个完整的像素。但如果每个Bitmap都使用32bit来表示一个像素的话，对内存来说是一个较大的负担，因此对于质量要求不高的Bitmap来说，可以采用较少的内存去表示一个像素。

色深指的是每一个像素点用多少bit来存储ARGB值，色深越大，图片的色彩越丰富，一般来说色深有8bit、16bit、32bit等，Bitmap.Config中的色深配置如下。

ALPHA_8: 这种方案只存储透明度通道，色深为8bit，使用场景特殊，比如设置遮盖效果等。
ARGB_8888: ARGB每个通道值采8bit来表示，色深为32bit，每个像素点需要4byte的内存来存储数据，图片质量高，所占内存大。
ARGB_4444: ARGB每个通道都是4位，色深为16bit，由于这种配置下的图片质量较差，Android官方已经将其标为弃用。
RGB_565: 色深为16bit，RGB通道值分别占5、6、5位，但是没有存储A通道值，所以不支持透明度，可用于对清晰度要求不高的照片。
RGBA_F16: 色深为64bit，该配置主要用于广色域与HDR内容。
HARDWARE: 这是一种特殊配置，该配置下，Bitmap会被存储在显存中，并且Bitmap是不可变的。这种配置仅适用于，当Bitmap唯一的操作就是将自己绘制在屏幕上时。

我们可以根据对图片质量的要求创建不同色深的Bitmap，如果对显示质量有较高的要求可以使用ARGB_8888，一般来说使用RGB_565即可，这也可以减少OOM的概率。

Bitmap b = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888);

1.2 通过采样加载大图

ImageView是显示Bitmap的载体，一般情况下ImageView的宽高会小于Bitmap，如果将一个完整的Bitmap加载到偏小的ImageView中会浪费内存。关于这个问题，Android官方提供了一个优化方法。

该方法通过比较ImageView与Bitmap的大小并计算采样率，最终将采样后的小图加载到内存中。流程如下：在调用BitmapFactory.decodeXXX(res, resId, BitmapFactory.Options)解析图片时，先将BitmapFactory.Options的inJustDecodeBounds设为true，此时不会将图片加载到内存中，而是只得到Bitmap的宽高，随后通过图片宽高计算采样率。得到采样率后再将inJustDecodeBounds设为false，再加载Bitmap时可以得到大图的采样图。

public static Bitmap decodeSampledBitmapFromResource(
            Resources res, int resId, int reqWidth, int reqHeight) {
    final BitmapFactory.Options options = new BitmapFactory.Options();
    // 该属性默认为false, 为true时不会将图片加载到内存中, 而是只计算宽高
    options.inJustDecodeBounds = true;
    BitmapFactory.decodeResource(res, resId, options);
    // 计算采样率
    options.inSampleSize = calculateInSampleSize(
            options, reqWidth, reqHeight);
    // 设置inJustDecodeBounds为false, 将图片加载到内存
    options.inJustDecodeBounds = false;
    return BitmapFactory.decodeResource(res, resId, options);
}

public static int calculateInSampleSize(
            BitmapFactory.Options options, int reqWidth, int reqHeight) {
    // 获得Bitmap的宽高
    final int height = options.outHeight;
    final int width = options.outWidth;
    // 计算采样率
    int inSampleSize = 1;
    if (height > reqHeight || width > reqWidth) {
        final int halfHeight = height / 2;
        final int halfWidth = width / 2;
        while ((halfHeight / inSampleSize) >= reqHeight
                && (halfWidth / inSampleSize) >= reqWidth) {
            inSampleSize *= 2;
        }
    }
    return inSampleSize;
}

如果使用Glide这类图片加载框架将Bitmap加载到ImageView中，框架会自动帮我们完成采样的工作。不过如果你需要获取某个Bitmap的缩略图，上述方法还是有用武之地的。

二、Bitmap相关应用

2.1 图片裁剪

图片裁剪是图片处理的基本功能，APP中的设置头像功能就需要用到图片裁剪，用户可以通过一个预览框在原图上裁剪出特定区域的图案。
系统本身提供了裁剪的功能，我们可以在A页面通过以下代码启动一个裁剪图片的Activity，裁剪结束在A页面的onActivityResult(...)中得到裁剪后的图片。

// uri为图片的地址
public void startCropPicture(Uri uri) {
    Intent intent = new Intent("com.android.camera.action.CROP");
    intent.setDataAndType(uri, "image/*");
    intent.putExtra("crop", "true");
    intent.putExtra("aspectX", 1); // 裁剪框比例
    intent.putExtra("aspectY", 1);
    intent.putExtra("outputX", 300); // 输出图片大小
    intent.putExtra("outputY", 300);
    intent.putExtra("scale", true);
    intent.putExtra("return-data", true);
    startActivityForResult(intent, REQUEST_CODE);
}

图片裁剪的原理很简单，通过Bitmap.createBitmap(originBitmap, left, top, width, height)即可在originBitmap上裁出指定区域的Bitmap，因此我们可以自己实现一个裁剪头像的功能。需要注意的是，Bitmap.createBitmap(...)方法参数中传入的坐标和宽高都是基于原始Bitmap的，如果传入的参数超出了原始Bitmap的宽高就会抛出异常。

本文Demo实现了裁剪图案的基础功能，拖动裁剪框右下角可以修改框大小，拖动其他区域可以移动裁剪框，可以通过本文开头的链接下载代码。

除了Bitmap.createBitmap(originBitmap, left, top, width, height)裁剪出指定的Bitmap，也可以在绘制时直接指定Bitmap的绘制区域，通过Canvas.drawBitmap(Bitmap bitmap, Rect src, RectF dst, Paint paint)即可实现，其中src表示对原图片的裁剪区域，dst表示对裁剪后的图片绘制到View上的区域。

2.2 图片拼接

图片拼接常见于分享时拼接所有图片，达到"一图看尽所有"的效果。代码示例如下，为了方便演示，示例中将4张一样的正方形图片splitBitmap拼接到了一起。

private Bitmap getJointBitmap(Bitmap splitBitmap) {
    int width = splitBitmap.getWidth();
    int height = splitBitmap.getHeight();
    Bitmap bitmap = Bitmap.createBitmap(
                width * 2, height * 2, Bitmap.Config.RGB_565);
    Canvas canvas = new Canvas(bitmap);
    canvas.drawBitmap(splitBitmap, 0, 0, null);
    canvas.drawBitmap(splitBitmap, width, 0, null);
    canvas.drawBitmap(splitBitmap, 0, height, null);
    canvas.drawBitmap(splitBitmap, width, height, null);
    return bitmap;
}

拼接图片前先创建了一个宽高都为splitBitmap宽高2倍的Bitmap作为容器，然后通过Canvas在容器的四个位置绘制4张一样的图片，最终效果如下。

2.3 矩阵变换

Bitmap是像素点的集合，我们可以通过矩阵运算改变每个像素点的位置，达到图形变换的效果。Android中可以通过Matrix类来进行变换，Matrix本身是一个3x3的矩阵，可以通过Matrix m = new Matrix()新建一个单位矩阵，原始矩阵的值如下所示。

[1 0 0]
[0 1 0]
[0 0 1]

Matrix中各个位置的变换信息如下所示，scale表示缩放，skew表示错切，trans表示平移，persp等表示透视参数。Bitmap中的每个像素点可以使用一个3x1的矩阵表示，其中x表示当前像素点的横坐标，y表示纵坐标。用该矩阵左乘Bitmap中的所有像素后，就能得到变换后的图像。

[scaleX  skewX   transX]     [x]     [scaleX * x + skewX * y + transX]
[skewY   scaleY  transY]  x  [y]  =  [skewY * x + scaleY * y + transY]
[persp0  persp1  persp2]     [1]     [persp0 * x + persp1 * y + persp2]

简单来说，Matrix是一个容器，保存了用户期望的矩阵变换信息。在将Matrix应用于Bitmap之前，我们可以对其进行各种操作，将变换信息保存进去。矩阵运算可以实现平移、旋转、缩放、错切，因此Matrix也为提供了类似方法。

setTranslate(float dx,float dy): 控制 Matrix 进行位移。
setSkew(float kx,float ky): 控制 Matrix 进行倾斜，kx、ky为X、Y方向上的比例。
setSkew(float kx,float ky,float px,float py): 控制 Matrix 以 px, py 为轴心进行倾斜，kx、ky为X、Y方向上的倾斜比例
setRotate(float degrees): 控制 Matrix 进行 depress 角度的旋转，轴心为(0,0)
setRotate(float degrees,float px,float py): 控制 Matrix 进行 depress 角度的旋转，轴心为(px,py)
setScale(float sx,float sy): 设置 Matrix 进行缩放，sx, sy 为 X, Y方向上的缩放比例。
setScale(float sx,float sy,float px,float py): 设置 Matrix 以(px,py)为轴心进行缩放，sx、sy 为 X、Y方向上的缩放比例

很多时候矩阵变换并不是单一的平移、旋转或缩放，这些变换经常结合在一起使用，此时setXXX()方法无法满足要求。因此Matrix提供了preXXX()和postXXX()方法来组合多个矩阵操作，多个矩阵操作之间通过乘法运算。由于矩阵的乘法是不满足交换律的，因此进行矩阵运算时需要注意乘法的顺序。

在使用preXXX()和postXXX()时，我们可以将矩阵变换的所有计算看成一个乘法列表，调用preXXX()方法时就是向列表头部添加操作，调用postXXX()时就是向列表尾部添加操作。例如以下代码中矩阵乘法的执行顺序就是2->1->3->4。需要注意的是，setXXX()方法会重置Matrix的变换，如果对下方执行完4个运算的Matrix调用setTranslate()方法，那么该Matrix就只有平移效果了。

Matrix matrix = new Matrix();
matrix.preScale(...); // 1
matrix.preTranslate(...); // 2
matrix.postTranslate(...); // 3
matrix.postRotate(...); // 4

2.4 颜色变换

颜色变换主要通过ColorFilter进行，通过Paint.setColorFilter(ColorFilter filter)可以设置颜色过滤器，该过滤器会对每一个像素的颜色进行过滤，得到最终的图像。ColorFilter有3个子类，这里主要介绍ColorMatrixColorFilter。

2.4.1 ColorMatrixColorFilter

该颜色过滤器通过矩阵进行色彩变换，先来介绍一下色彩矩阵，Android中的色彩是以ARGB的形式存储的，我们可以通过ColorMatrix修改颜色的值，ColorMatrix定义了一个4x5的float矩阵，矩阵的4行分别表示在RGBA上的向量，其范围值在0f-2f之间，如果为1就是原效果。每一行的第5列表示偏移量，就是指在当前通道上增大或减小多少。

ColorMatrix colorMatrix = new ColorMatrix(new float[]{
		1, 0, 0, 0, 0,
		0, 1, 0, 0, 0,
		0, 0, 1, 0, 0,
		0, 0, 0, 1, 0,
});

ColorMatrix与颜色之间的运算如下所示，其实就是矩阵运算，与上一节的Matrix类似。

[a, b, c, d, e]     [R]     [a*R + b*G + c*B + d*A + e]
[f, g, h, i, j]     [G]     [f*R + g*G + h*B + i*A + j]
[k, l, m, n, o]  x  [B]  =  [k*R + l*G + m*B + n*A + o]
[p, q, r, s, t]     [A]     [p*R + q*G + r*B + s*A + t]
                    [1]

有了ColorMatrix，就可以对Bitmap上所有的颜色进行修改，例如调整每个通道的值，将初始值1改为0.5，就可以将Bitmap变暗。不过我不太了解色彩，也没在项目中实际使用过，感兴趣的朋友可以看参考1。

2.5 图像混合

图像混合是指对两张原始图像(我们称为DST和SRC)的内容按某种规则合成，从而形成一张包含DST和SRC特点的新图像。例如DST为圆形图像，SRC为照片，可以将它们合成为圆形照片。

Android通过PorterDuffXfermode实现图像混合，它实际上是通过公式对两张图像在Canvas上的所有像素进行ARGB运算，最终在每个像素点得到新的ARGB值。需要注意的是，在onDraw(Canvas)方法中进行图像混合时，先绘制的图像为DST，后绘制的图像为SRC，因此需要注意图像的绘制顺序。

PorterDuffXfermode一共提供了18种混合模式，它们的计算公式如下，Sa表示SRC的ALPHA通道，Sc表示SRC的颜色；Da表示DST的ALPHA通道，Dc表示DST的颜色。以CLEAR为例，该模式会清除SRC区域的所有内容。

合成模式	公式
CLEAR	[0, 0]
SRC	[Sa, Sc]
DST	[Da, Dc]
SRC_OVER	[Sa + (1 - Sa)*Da, Rc = Sc + (1 - Sa)*Dc]
DST_OVER	[Sa + (1 - Sa)*Da, Rc = Dc + (1 - Da)*Sc]
SRC_IN	[Sa * Da, Sc * Da]
DST_IN	[Sa * Da, Sa * Dc]
SRC_OUT	[Sa * (1 - Da), Sc * (1 - Da)]
DST_OUT	[Da * (1 - Sa), Dc * (1 - Sa)]
SRC_ATOP	[Da, Sc * Da + (1 - Sa) * Dc]
DST_ATOP	[Sa, Sa * Dc + Sc * (1 - Da)]
XOR	[Sa + Da - 2 * Sa * Da, Sc * (1 - Da) + (1 - Sa) * Dc]
DARKEN	[Sa + Da - Sa * Da, Sc * (1 - Da) + Dc * (1 - Sa) + min(Sc, Dc)]
LIGHTEN	[Sa + Da - Sa * Da, Sc * (1 - Da) + Dc * (1 - Sa) + max(Sc, Dc)]
MULTIPLY	[Sa * Da, Sc * Dc]
SCREEN	[Sa + Da - Sa * Da, Sc + Dc - Sc * Dc]
ADD	Saturate(S + D)

如果你使用过PorterDuffXfermode，你可能见过下面这张图，Android官方的样例就是这个效果，不过官方只提供了16种混合模式的样例，我在Demo中把ADD和OVERLAY也添加了进去。

当然你也可能见过这张图。

乍一看，这两张图中的DST和SRC原始图像都是一样的，但是为什么使用了同样的混合模式后，显示的结果不同呢？

关键就在于DST和SRC的大小，第一张图中的DST和SRC都是Bitmap，它们的大小与Canvas相等，只是在Bitmap的某个区域绘制了圆和矩形。Demo代码如下，可以看到makeDst()和makeSrc()中创建的Bitmap与整个View(或者说Canvas)是相等的。这也解释了为什么第一张图的CLEAR模式下的结果是空白的，因为SRC的大小是整个View的大小，CLEAR模式表示清除SRC区域的内容，最终将整个View的内容清除了。

public class XFerModeView extends View {

    private Paint mPaint;
    private PorterDuffXfermode mPorterDuffXfermode;
    private int mWidth;
    private int mHeight;

    // 省略构造方法......

    private void init() {
        setLayerType(LAYER_TYPE_SOFTWARE, null);
        mPaint = new Paint(Paint.ANTI_ALIAS_FLAG);
        mPorterDuffXfermode = new PorterDuffXfermode(PorterDuff.Mode.CLEAR);
    }

    @Override
    protected void onSizeChanged(int w, int h, int oldw, int oldh) {
        super.onSizeChanged(w, h, oldw, oldh);
        if (mWidth != w || mHeight != h) {
            mWidth = w;
            mHeight = h;
            invalidate();
        }
    }

    @Override
    protected void onDraw(Canvas canvas) {
        super.onDraw(canvas);
        drawBackground(canvas);
        int sc = canvas.saveLayer(0, 0, mWidth, mHeight, null);
        drawCompositionInFullSize(canvas);
        canvas.restoreToCount(sc);
    }

    private void drawBackground(Canvas canvas) {
        mPaint.setStyle(Paint.Style.STROKE);
        mPaint.setStrokeWidth(5);
        mPaint.setColor(Color.BLACK);
        canvas.drawRect(0, 0, mWidth, mHeight, mPaint);
    }

    private void drawCompositionInFullSize(Canvas canvas) {
        mPaint.setStyle(Paint.Style.FILL);
        Bitmap dst = makeDst();
        Bitmap src = makeSrc();
        // 绘制DST
        canvas.drawBitmap(dst, 0, 0, mPaint);
        // 设置图像混合模式
        mPaint.setXfermode(mPorterDuffXfermode);
        // 绘制SRC
        canvas.drawBitmap(src, 0, 0, mPaint);
        // 清除图像混合模式
        mPaint.setXfermode(null);
    }

    private Bitmap makeDst() {
        Bitmap bm = Bitmap.createBitmap(mWidth, mHeight, Bitmap.Config.ARGB_8888);
        Canvas c = new Canvas(bm);
        mPaint.setColor(0xFFFFCC44);
        c.drawOval(10, 10, mWidth * 3f / 4, mHeight * 3f / 4, mPaint);
        return bm;
    }

    private Bitmap makeSrc() {
        Bitmap bm = Bitmap.createBitmap(mWidth, mHeight, Bitmap.Config.ARGB_8888);
        Canvas c = new Canvas(bm);
        mPaint.setColor(0xFF66AAFF);
        c.drawRect(mWidth * 1f / 3, mHeight * 1f / 3,
                mWidth * 19f / 20, mHeight * 19f / 20, mPaint);
        return bm;
    }

在第二张图中，绘制SRC和DST时创建的图像大小就是圆或矩形的大小，最终的结果也与第一张图有所不同，修改后的代码如下。还是以CLEAR模式为例，此时清除的就只是矩形区域SRC的图像，可以看到DST中与SRC相交的部分被清除了。

public class XFerModeView extends View {

    // 省略重复代码......

    @Override
    protected void onDraw(Canvas canvas) {
        super.onDraw(canvas);
        drawBackground(canvas);
        int sc = canvas.saveLayer(0, 0, mWidth, mHeight, null);
        drawCompositionInSelfSize(canvas);
        canvas.restoreToCount(sc);
    }

    /**
     * 混合图像的大小只有可见区域大小
     */
    private void drawCompositionInSelfSize(Canvas canvas) {
        mPaint.setStyle(Paint.Style.FILL);
        mPaint.setColor(0xFFFFCC44);
        canvas.drawOval(10, 10, mWidth * 3f / 4, mHeight * 3f / 4, mPaint);
        mPaint.setXfermode(mPorterDuffXfermode);
        mPaint.setColor(0xFF66AAFF);
        canvas.drawRect(mWidth * 1f / 3, mHeight * 1f / 3,
                mWidth * 19f / 20, mHeight * 19f / 20, mPaint);
        mPaint.setXfermode(null);
    }
}

使用图像混合时还有一个要注意的地方：上述代码在onDraw(Canvas)方法中绘制混合图像时会先调用int sc = canvas.saveLayer(...)生成一个新的图层(Layer)，sc表示图层的编号，随后在新Layer上绘制DST和SRC，绘制完后将该Layer添加到Canvas上。那么这里为什么需要新的Layer来绘制DST和SRC，而不是直接在Canvas上绘制呢？

Layer可以理解为画布Canvas的一个层级，默认情况下Canvas只有一个Layer，所有的绘制都在同一图层上。当需要绘制多层图像时，可以通过canvas.saveLayer(...)生成新的Layer，在新Layer上绘制的内容是独立的，不会影响到其他Layer的内容，调用canvas. restoreToCount(int sc)时将该Layer覆盖到Canvas现有的图像上。Canvas通过栈的形式管理Layer，示意图如下。

之前提到进行图像混合时，先绘制的内容是DST，后绘制的是SRC。如果不新建Layer的话，在绘制SRC时，Canvas上的所有内容都会被当作DST，所以背景等内容也会参与图像混合，很容易得到错误的效果。

以上就是图像混合的基本介绍，图像混合的应用场景比较广泛，这里介绍几种常见的场景。

2.5.1 图像切割

图像切割用于将图像切割成特定的形状。可以是常见形状如圆形或圆角矩形，也可以切割为五角星这样的非常规形状，使用这一类非常规形状时需要该形状的底图。

将图像裁剪为圆角矩形时比较简单，在onDraw(Canvas)中新建图层，绘制圆角矩形作为DST，再绘制原图作为SRC即可，此时图像混合模式应设置为SRC_IN，代码如下，decodeSampledBitmapFromResource(...)就是1.2节的大图采样。

public class RoundCornerView extends View {

    private Paint mPaint;
    private PorterDuffXfermode mFerMode;
    private Bitmap mBitmap;
    private Rect mBitmapRect;
    private int mWidth;
    private int mHeight;

    // 省略构造函数...

    private void init() {
        mPaint = new Paint(Paint.ANTI_ALIAS_FLAG);
        mFerMode = new PorterDuffXfermode(PorterDuff.Mode.SRC_IN);
    }

    @Override
    protected void onSizeChanged(int w, int h, int oldw, int oldh) {
        super.onSizeChanged(w, h, oldw, oldh);
        if (mWidth != w || mHeight != h) {
            mWidth = w;
            mHeight = h;
            mBitmap = BitmapUtils.decodeSampledBitmapFromResource(
                    getContext().getResources(), R.drawable.compress_test, mWidth, mHeight);
            mBitmapRect = new Rect(0, 0, mWidth, mHeight);
            invalidate();
        }
    }

    @Override
    protected void onDraw(Canvas canvas) {
        super.onDraw(canvas);
        int sc = canvas.saveLayer(0, 0, mWidth, mHeight, null);
        canvas.drawRoundRect(0, 0, mWidth, mHeight, 50, 50, mPaint);
        mPaint.setXfermode(mFerMode);
        canvas.drawBitmap(mBitmap, null, mBitmapRect, mPaint);
        mPaint.setXfermode(null);
        canvas.restoreToCount(sc);
    }

    ......
}

最终效果如下，同理可以将图像切割为圆形等基础形状。

如果要将图像切割为五角星这样的图案，就需要使用一张五角星的底图，需要注意的是，底图上五角星以外的部分应该是透明的，否则切割出来还是原来的形状。其代码与切割为圆角矩形大同小异，只需要将绘制圆角矩形的部分换成绘制五角星即可。

public class StarPicView extends View {

    private Paint mPaint;
    private PorterDuffXfermode mMode;
    private Bitmap mBgBitmap;
    private Bitmap mBitmap;
    private int mWidth, mHeight;
    private Rect mDrawRect;

    // 省略构造函数......

    private void init() {
        mPaint = new Paint(Paint.ANTI_ALIAS_FLAG);
        mMode = new PorterDuffXfermode(PorterDuff.Mode.SRC_IN);
    }

    @Override
    protected void onSizeChanged(int w, int h, int oldw, int oldh) {
        super.onSizeChanged(w, h, oldw, oldh);
        if (mWidth != w || mHeight != h) {
            mWidth = w;
            mHeight = h;
            mBgBitmap = BitmapUtils.decodeSampledBitmapFromResource(
                    getContext().getResources(), R.drawable.star4, mWidth, mHeight);
            mBitmap = BitmapUtils.decodeSampledBitmapFromResource(
                    getContext().getResources(), R.drawable.icon3, mWidth, mHeight);
            mDrawRect = new Rect(0, 0, mWidth, mHeight);
            invalidate();
        }
    }

    @Override
    protected void onDraw(Canvas canvas) {
        super.onDraw(canvas);
        int sc = canvas.saveLayer(0, 0, mWidth, mHeight, null);
        canvas.drawBitmap(mBgBitmap, null, mDrawRect, mPaint);
        mPaint.setXfermode(mMode);
        canvas.drawBitmap(mBitmap, null, mDrawRect, mPaint);
        mPaint.setXfermode(null);
        canvas.restoreToCount(sc);
    }
}

最终的效果如下。

2.5.2 色彩合成

色彩合成可以为图片添加新的效果，当使用纯色与照片混合时，可以改变图片整体的色调。例如黄色可以让图片具有泛黄的怀旧效果，红色可以让图片更温暖。以下代码通过SCREEN混合模式将半透明的红色与图片混合。

public class ColorComposeView extends View {

    ......

    private void init() {
        setLayerType(LAYER_TYPE_SOFTWARE, null);
        mPaint = new Paint(Paint.ANTI_ALIAS_FLAG);
        mMode = new PorterDuffXfermode(PorterDuff.Mode.SCREEN);
    }

    ......

    @Override
    protected void onDraw(Canvas canvas) {
        super.onDraw(canvas);
        canvas.drawColor(Color.WHITE);
        int sc = canvas.saveLayer(0, 0, mWidth, mHeight, null);
        canvas.drawColor(0x44FF0000);
        mPaint.setXfermode(mMode);
        canvas.drawBitmap(mBitmap, null, mRect, mPaint);
        mPaint.setXfermode(null);
        canvas.restoreToCount(sc);
    }
}

怎么样，是不是觉得小姐姐看上去都温柔了一些？

出了纯色混合，也可以将两张图片进行合成，例如通过一张毛玻璃的底图，可以为照片添加一定的模糊效果，底图如下所示。

绘制时将底图作为DST，将照片作为SRC，混合模式使用OVERLAY，代码与绘制切割五角星的大同小异，不再赘述。最终得到如下的效果。

2.5.3 图像alpha渐变

之前遇到一个很有意思的UI需求，给定一张底图，要求绘制时图像的透明度从上到下是渐变的1-0，效果如下所示。因为background是白色，所以透明部分透出来的是白色。

这个其实也很简单，在本地新建一个渐变的drawable，然后通过XOR模式进行混合，具体代码可参考文章开头代码。

三、图片压缩

3.1 质量压缩

质量压缩减小的是图片在磁盘上的体积大小，通过Bitmap.compress(CompressFormat, quality, outputStream)将Bitmap保存到本地时，可以选择对应的文件格式以及质量标准，文件格式包含JPEG、PNG和WEBP三种，质量的取值为0-100，0代表最差质量，100代表最高质量。WEBP格式将会在API30被弃用，取而代之的是WEBP_LOSSLESS和WEBP_LOSSY，用于更清晰地描述是无损压缩还是有损压缩。

将Bitmap保存为60质量标准的jpeg的代码如下。

private void qualityCompressJPG() {
    OutputStream os = getOutputStreamByName("jpgFile60.jpeg");
    if (os != null) {
        mOriginBitmap.compress(Bitmap.CompressFormat.JPEG, 60, os);
    }
}

private OutputStream getOutputStreamByName(String fileName) {
    BufferedOutputStream bos = null;
    File dir = new File(FILE_DIR);
    boolean dirExist = true;
    if (!dir.exists()) {
        dirExist = dir.mkdirs();
    }
    if (dirExist) {
        File file = new File(dir, fileName);
        if (file.exists()) {
            file.delete();
        }
        try {
            boolean fileExist;
            fileExist = file.createNewFile();
            if (fileExist) {
                bos = new BufferedOutputStream(new FileOutputStream(file));
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    return bos;
}

三种图片格式中，PNG为无损压缩，因此当文件格式选择PNG时Bitmap.compress(CompressFormat, quality, outputStream)方法会无视quality参数。下图为保存同一张图片时，选择不同的格式与不同质量的对比。可以发现WEBP格式所占用的空间是比较理想的，如果APP的体积比较大，可以考虑把资源文件转化为WEBP来节省空间。

3.2 尺寸压缩

尺寸压缩就是指压缩原始Bitmap的宽高，通过减小像素个数来减小Bitmap占用的空间，这种压缩方式下，不管Bitmap所占的内存，还是图片保存到磁盘上所占的空间都会有显著的减小。

尺寸压缩可以通过Bitmap.createScaledBitmap(Bitmap src, int dstWidth, int dstHeight, boolean filter)来创建压缩后的Bitmap，filter参数可以简单地理解为，如果为true的话就会消耗更长的时间获得更好的图片质量，false则相反。

private void sizeCompress1(int scale) {
    int width = mOriginBitmap.getWidth() / scale;
    int height = mOriginBitmap.getHeight() / scale;
    Bitmap b = Bitmap.createScaledBitmap(
                    mOriginBitmap, width, height, false);
    OutputStream os = getOutputStreamByName("sizeCompress1.webp");
    if (os != null) {
        b.compress(Bitmap.CompressFormat.WEBP, 100, os);
    }
}

通过Bitmap b = Bitmap.createScaledBitmap(src, w, h, filter)来创建Bitmap时，它的Config是基于原始Bitmap的，如果原始Bitmap的Config是ARGB_8888而压缩后又不需要这么高的清晰度，那么可以选择新建RGB_565的Bitmap，并通过Canvas将压缩后的图片绘制上去。

private void sizeCompress2(int scale) {
    int width = mOriginBitmap.getWidth() / scale;
    int height = mOriginBitmap.getHeight() / scale;
    Bitmap b = Bitmap.createBitmap(width, height, Bitmap.Config.RGB_565);
    Canvas canvas = new Canvas(b);
    Rect rect = new Rect(0, 0, width, height);
    canvas.drawBitmap(mOriginBitmap, null, rect, null);
    OutputStream os = getOutputStreamByName("sizeCompress2_565.webp");
    if (os != null) {
        b.compress(Bitmap.CompressFormat.WEBP, 100, os);
    }
}

如果第2种方式选择ARGB_8888，创建出来的Bitmap其所占的内存(通过Bitmap.getByteCount()计算)以及保存到磁盘上的大小都与第1种方式相同。如果选择RGB_565，相比于第1种方式，Bitmap所占的内存会缩小一半，保存到磁盘上后的体积也会适当减小。

参考&推荐阅读

1. Android自定义控件其实很简单
2. Android动态模糊实现的研究