使用Xfermode绘制一个颜色渐变的圆形进度条

package com.example.administrator.cycleprogressview;

import android.animation.ValueAnimator;
import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.graphics.PorterDuff;
import android.graphics.PorterDuffXfermode;
import android.graphics.RectF;
import android.graphics.drawable.GradientDrawable;
import android.util.AttributeSet;
import android.util.Log;
import android.view.View;
import android.view.animation.AccelerateDecelerateInterpolator;

/**
* Created by zq_zhan on 2017/2/28.
*/

public class CycleProgressView extends View {

public CycleProgressView(Context context) {
this(context,null);
}

public CycleProgressView(Context context, AttributeSet attrs) {
this(context,attrs,0);
}

public CycleProgressView(Context context, AttributeSet attrs, int defStyleAttr) {
super(context, attrs, defStyleAttr);
init();
}

private int width;
private int height;
private float max;
private float progress;
private float angle;
private int unit;
private float unitAngle;
private Paint cyclePaint;
private Paint linPaint;
private Paint ballPaint;
private RectF rectF;
private int min;
private int ballRadio;
private int cycleWidth;

private int topColor;
private int bottomColor;

private Bitmap mixtureBitmap;

@Override
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
width = getMeasuredWidth();
height = getMeasuredHeight();
min = Math.min(width,height)/2-20;
rectF = new RectF(width/2-min,height/2-min,width/2+min,height/2+min);
super.onMeasure(widthMeasureSpec, heightMeasureSpec);
}

public void setMax(float max){
this.max = max;
}

public void setProgress(float progress){
this.progress = progress;
doAnimation();
}

private void updateProgress(float progress){
angle = progress/max*270;
invalidate();
}

public void setUnit(int unit){
this.unit = unit;
unitAngle = 270/max*unit;
}

public void setTopColor(int topColor){
this.topColor = topColor;
mDrawable = new GradientDrawable(GradientDrawable.Orientation.TOP_BOTTOM, new int[] {topColor,bottomColor});
}

public void setBottomColor(int bottomColor){
this.bottomColor = bottomColor;
mDrawable = new GradientDrawable(GradientDrawable.Orientation.TOP_BOTTOM, new int[] {topColor,bottomColor});
}

private void init(){

ballRadio = 10;
cycleWidth = 50;
angle = 86;
unitAngle = 3;
cyclePaint = new Paint();
cyclePaint.setColor(Color.BLUE);
cyclePaint.setStyle(Paint.Style.STROKE);
cyclePaint.setStrokeWidth(50);
cyclePaint.setAntiAlias(true);

linPaint = new Paint();
linPaint.setColor(Color.BLUE);
linPaint.setStyle(Paint.Style.STROKE);
linPaint.setStrokeWidth(2);
linPaint.setStrokeCap(Paint.Cap.ROUND);
linPaint.setAntiAlias(true);

ballPaint = new Paint();
ballPaint.setColor(Color.BLUE);
ballPaint.setStyle(Paint.Style.FILL);
ballPaint.setAntiAlias(true);

topColor = getResources().getColor(R.color.colorAccen);
bottomColor = getResources().getColor(R.color.colorAccen1);
//颜色渐变Drawable;
mDrawable = new GradientDrawable(GradientDrawable.Orientation.TOP_BOTTOM, new int[] {topColor,bottomColor});
}

GradientDrawable mDrawable;

private void drawStrokeCycle(Canv
4000
as canvas){
//将Drawable转换成bitmap
mDrawable.setGradientType(GradientDrawable.LINEAR_GRADIENT);
mDrawable.setBounds(0,0,width,height);
mDrawable.setSize(width,height);
mixtureBitmap = Bitmap.createBitmap(width,height, Bitmap.Config.ARGB_8888);
Canvas canvas1 = new Canvas(mixtureBitmap);
mDrawable.draw(canvas1);

//使用Xfermode将渐变drawable转换的bitmap和想绘制的图形进行求交集即可绘制一个颜色渐变的图形
int layerId = canvas.saveLayer(0, 0, width, height, null, Canvas.ALL_SAVE_FLAG);
//使用Xfermode前要关闭硬件加速，不然会达不到想要的效果
setLayerType(LAYER_TYPE_HARDWARE, null);

canvas.drawCircle(width/2,height/2,min-cycleWidth/2-ballRadio,cyclePaint);
cyclePaint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.SRC_IN));
canvas.drawBitmap(mixtureBitmap,null,rectF,cyclePaint);
cyclePaint.setXfermode(null);
canvas.restoreToCount(layerId);
}

private void drawScale(Canvas canvas){

float addAngle = 0;
while(addAngle<angle){
linPaint.setColor(Color.WHITE);
linPaint.setStrokeWidth(2);
canvas.drawLine(width/2-min+20,height/2,width/2-min+45,height/2,linPaint);
canvas.rotate(unitAngle,width/2,height/2);
addAngle += unitAngle;
}
canvas.rotate(angle-addAngle,width/2,height/2);
linPaint.setStrokeWidth(5);
canvas.drawLine(width/2-min+17,height/2,width/2-min+50,height/2,linPaint);
drawBall(canvas);
}

private void drawBall(Canvas canvas){
ballPaint.setColor(Color.WHITE);
linPaint.setStrokeWidth(1);
linPaint.setColor(Color.GREEN);
canvas.drawCircle(width/2-min,height/2,18,ballPaint);
canvas.drawCircle(width/2-min,height/2,18,linPaint);
ballPaint.setColor(Color.GREEN);
canvas.drawCircle(width/2-min,height/2,10,ballPaint);
}

private float[] calculateBallCenter(){
float[] center = new float[2];
float dy = (float) (Math.sin(Math.toRadians(angle))*min);
float dx = (float) (Math.cos(Math.toRadians(angle))*min);
center[0]= width/2 - dx;
center[1] = height/2 - dy;
return center;
}

@Override
protected void onDraw(Canvas canvas) {
drawStrokeCycle(canvas);
canvas.rotate(-45,width/2,height/2);
linPaint.setColor(Color.GREEN);
linPaint.setStrokeWidth(3);
canvas.drawArc(rectF,-180,angle,false,linPaint);
drawScale(canvas);
super.onDraw(canvas);
}

//动画效果
private void doAnimation(){
ValueAnimator animator = ValueAnimator.ofFloat(0,1);
animator.setDuration(1500);
animator.setInterpolator(new AccelerateDecelerateInterpolator());
animator.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
@Override
public void onAnimationUpdate(ValueAnimator animation) {
float currentValue = (float) animation.getAnimatedValue();
float progress1 = progress*currentValue;
updateProgress(progress1);
}
});
animator.start();
}
}