public class CircleProgress extends View {

    private static final String TAG = CircleProgress.class.getSimpleName();
    private Context mContext;

    //預設大小
    private int mDefaultSize;
    //是否開啟抗鋸齒
    private boolean antiAlias;
    //繪製標題
    private TextPaint mHintPaint;
    private CharSequence mHint;
    private
 
 int mHintColor;
    private float mHintSize;

    //繪製單位
    private TextPaint mUnitPaint;
    private CharSequence mUnit;
    private int mUnitColor;
    private float mUnitSize;

    //繪製數值
    private TextPaint mValuePaint;
    private float mValue;
    private float mMaxValue;
    private int mPrecision;
    private
 
 String mPrecisionFormat;
    private int mValueColor;
    private float mValueSize;

    //繪製圓弧
    private Paint mArcPaint;
    private int mArcColor1, mArcColor2, mArcColor3;
    private float mArcWidth;
    private float mStartAngle, mSweepAngle;
    private RectF mRectF;
    //漸變
    private Matrix mRotateMatrix;
    //漸變的顏色是360度，如果只顯示270，那麼則會缺失部分顏色
 

    private SweepGradient mSweepGradient;
    private int[] mGradientColors = {Color.GREEN, Color.YELLOW, Color.RED};
    //當前進度，[0.0f,1.0f]
    private float mPercent;
    //動畫時間
    private long mAnimTime;
    //屬性動畫
    private ValueAnimator mAnimator;

    //繪製背景圓弧
    private Paint mBgArcPaint;
    private int mBgArcColor;
    private float mBgArcWidth;

    //圓心座標，半徑
    private float mFloatX, mFloatY, mRadius;
    //在螢幕上的座標
    private int[] mLocationOnScreen = new int[2];

    public CircleProgress(Context context, AttributeSet attrs) {
        super(context, attrs);
        init(context, attrs);
    }

    private void init(Context context, AttributeSet attrs) {
        mContext = context;
        mDefaultSize = MiscUtil.dipToPx(mContext, 150);
        mAnimator = new ValueAnimator();
        getLocationOnScreen(mLocationOnScreen);
        mRectF = new RectF();
        initAttrs(attrs);
        initPaint();
        setValue(mValue);
    }

    private void initAttrs(AttributeSet attrs) {
        TypedArray typedArray = mContext.obtainStyledAttributes(attrs, R.styleable.CircleProgressBar);

        antiAlias = typedArray.getBoolean(R.styleable.CircleProgressBar_antiAlias, false);

        mHint = typedArray.getString(R.styleable.CircleProgressBar_hint);
        mHintColor = typedArray.getColor(R.styleable.CircleProgressBar_hintColor, Color.BLACK);
        mHintSize = typedArray.getDimension(R.styleable.CircleProgressBar_hintSize, 15);

        mValue = typedArray.getFloat(R.styleable.CircleProgressBar_value, 0);
        mMaxValue = typedArray.getFloat(R.styleable.CircleProgressBar_maxValue, 0);
        //內容數值精度格式
        mPrecision = typedArray.getInt(R.styleable.CircleProgressBar_precision, 0);
        mPrecisionFormat = getPrecisionFormat(mPrecision);
        mValueColor = typedArray.getColor(R.styleable.CircleProgressBar_valueColor, Color.BLACK);
        mValueSize = typedArray.getDimension(R.styleable.CircleProgressBar_valueSize, 60);

        mUnit = typedArray.getString(R.styleable.CircleProgressBar_unit);
        mUnitColor = typedArray.getColor(R.styleable.CircleProgressBar_unitColor, Color.BLACK);
        mUnitSize = typedArray.getDimension(R.styleable.CircleProgressBar_unitSize, 15);

        // 設定漸變色
        mArcColor1 = typedArray.getColor(R.styleable.CircleProgressBar_arcColor1, Color.GREEN);
        mArcColor2 = typedArray.getColor(R.styleable.CircleProgressBar_arcColor2, Color.YELLOW);
        mArcColor3 = typedArray.getColor(R.styleable.CircleProgressBar_arcColor3, Color.RED);
        mGradientColors = new int[]{mArcColor1, mArcColor2, mArcColor3};

        mArcWidth = typedArray.getDimension(R.styleable.CircleProgressBar_arcWidth, 15);
        mStartAngle = typedArray.getFloat(R.styleable.CircleProgressBar_startAngle, 270);
        mSweepAngle = typedArray.getFloat(R.styleable.CircleProgressBar_sweepAngle, 360);

        mBgArcColor = typedArray.getColor(R.styleable.CircleProgressBar_bgArcColor, Color.WHITE);
        mBgArcWidth = typedArray.getDimension(R.styleable.CircleProgressBar_bgArcWidth, 15);

        //mPercent = typedArray.getFloat(R.styleable.CircleProgressBar_percent, 0);
        mAnimTime = typedArray.getInt(R.styleable.CircleProgressBar_animTime, 1000);

        typedArray.recycle();
    }

    private String getPrecisionFormat(int precision) {
        return "%." + precision + "f";
    }

    private void initPaint() {
        mHintPaint = new TextPaint();
        // 設定抗鋸齒,會消耗較大資源，繪製圖形速度會變慢。
        mHintPaint.setAntiAlias(antiAlias);
        // 設定繪製文字大小
        mHintPaint.setTextSize(mHintSize);
        // 設定畫筆顏色
        mHintPaint.setColor(mHintColor);
        // 從中間向兩邊繪製，不需要再次計算文字
        mHintPaint.setTextAlign(Paint.Align.CENTER);

        mValuePaint = new TextPaint();
        mValuePaint.setAntiAlias(antiAlias);
        mValuePaint.setTextSize(mValueSize);
        mValuePaint.setColor(mValueColor);
        // 設定Typeface物件，即字型風格，包括粗體，斜體以及襯線體，非襯線體等
        mValuePaint.setTypeface(Typeface.DEFAULT_BOLD);
        mValuePaint.setTextAlign(Paint.Align.CENTER);

        mUnitPaint = new TextPaint();
        mUnitPaint.setAntiAlias(antiAlias);
        mUnitPaint.setTextSize(mUnitSize);
        mUnitPaint.setColor(mUnitColor);
        mUnitPaint.setTextAlign(Paint.Align.CENTER);

        mArcPaint = new Paint();
        mArcPaint.setAntiAlias(antiAlias);
        mArcPaint.setColor(mArcColor1);
        // 設定畫筆的樣式，為FILL，FILL_OR_STROKE，或STROKE
        mArcPaint.setStyle(Paint.Style.STROKE);
        // 設定畫筆粗細
        mArcPaint.setStrokeWidth(mArcWidth);
        // 當畫筆樣式為STROKE或FILL_OR_STROKE時，設定筆刷的圖形樣式，如圓形樣式
        // Cap.ROUND,或方形樣式 Cap.SQUARE
        mArcPaint.setStrokeCap(Paint.Cap.ROUND);
        mRotateMatrix = new Matrix();

        mBgArcPaint = new Paint();
        mBgArcPaint.setAntiAlias(antiAlias);
        mBgArcPaint.setColor(mBgArcColor);
        mBgArcPaint.setStyle(Paint.Style.STROKE);
        mBgArcPaint.setStrokeWidth(mBgArcWidth);
        mBgArcPaint.setStrokeCap(Paint.Cap.ROUND);
    }

    @Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        super.onMeasure(widthMeasureSpec, heightMeasureSpec);
        //設定預設內邊距，防止圓弧與邊界重疊
        int padding = MiscUtil.dipToPx(mContext, 5);
        setPadding(padding, padding, padding, padding);
        //因為是畫圓，所以寬高相等
        int measuredWidth = MiscUtil.measure(widthMeasureSpec, mDefaultSize);
        int measuredHeight = MiscUtil.measure(heightMeasureSpec, mDefaultSize);
        //求最小值作為實際值
        int size = Math.min(measuredWidth, measuredHeight);
        setMeasuredDimension(measuredWidth + getPaddingLeft() + getPaddingRight(),
                measuredHeight + getPaddingTop() + getPaddingBottom());
        //獲取圓的相關引數
        mFloatX = mLocationOnScreen[0] + size / 2 + getPaddingLeft();
        mFloatY = mLocationOnScreen[1] + size / 2 + getPaddingTop();
        //求圓弧和背景圓弧的最大寬度
        float maxArcWidth = Math.max(mArcWidth, mBgArcWidth);
        //減去圓弧的寬度，否則會造成部分圓弧繪製在外圍，通過clipPadding屬性可以解決
        mRadius = size / 2 - maxArcWidth;
        //繪製圓弧的邊界
        mRectF.left = mLocationOnScreen[0] + getPaddingLeft();
        mRectF.top = mLocationOnScreen[1] + getPaddingTop();
        mRectF.right = mRectF.left + size;
        mRectF.bottom = mRectF.top + size;
        updateArcPaint();
    }

    @Override
    protected void onDraw(Canvas canvas) {
        super.onDraw(canvas);
        drawText(canvas);
        drawArc(canvas);
    }

    /**
     * 繪製內容文字
     *
     * @param canvas
     */
    private void drawText(Canvas canvas) {
        // 計算文字寬度，由於Paint已設定為居中繪製，故此處不需要重新計算
        // float textWidth = mValuePaint.measureText(mValue.toString());
        // float x = mFloatX - textWidth / 2;
        float y = mFloatY - (mValuePaint.descent() + mValuePaint.ascent()) / 2;
        canvas.drawText(String.format(mPrecisionFormat, mValue), mFloatX, y, mValuePaint);

        if (mHint != null) {
            float hy = mFloatY * 2 / 3 - (mHintPaint.descent() + mHintPaint.ascent()) / 2;
            canvas.drawText(mHint.toString(), mFloatX, hy, mHintPaint);
        }

        if (mUnit != null) {
            float uy = mFloatY * 4 / 3 - (mUnitPaint.descent() + mUnitPaint.ascent()) / 2;
            canvas.drawText(mUnit.toString(), mFloatX, uy, mUnitPaint);
        }
    }

    private void drawArc(Canvas canvas) {
        // 繪製背景圓弧
        // 從進度圓弧結束的地方開始重新繪製，優化效能
        float currentAngle = mSweepAngle * mPercent;
        canvas.drawArc(mRectF, mStartAngle, mSweepAngle, false, mBgArcPaint);
        // 第一個引數 oval 為 RectF 型別，即圓弧顯示區域
        // startAngle 和 sweepAngle  均為 float 型別，分別表示圓弧起始角度和圓弧度數
        // 3點鐘方向為0度，順時針遞增
        // 如果 startAngle < 0 或者 > 360,則相當於 startAngle % 360
        // useCenter:如果為True時，在繪製圓弧時將圓心包括在內，通常用來繪製扇形
        canvas.drawArc(mRectF, mStartAngle, currentAngle, false, mArcPaint);
    }

    /**
     * 更新圓弧畫筆
     */
    private void updateArcPaint() {
        // 設定漸變
        mSweepGradient = new SweepGradient(mFloatX, mFloatY, mGradientColors, null);
        // 矩陣變化，-5是因為開始顏色可能會與結束顏色重疊
        mRotateMatrix.setRotate(mStartAngle - 5, mFloatX, mFloatY);
        mSweepGradient.setLocalMatrix(mRotateMatrix);
        mArcPaint.setShader(mSweepGradient);
    }

    public boolean isAntiAlias() {
        return antiAlias;
    }

    public CharSequence getHint() {
        return mHint;
    }

    public void setHint(CharSequence hint) {
        mHint = hint;
    }

    public CharSequence getUnit() {
        return mUnit;
    }

    public void setUnit(CharSequence unit) {
        mUnit = unit;
    }

    public float getValue() {
        return mValue;
    }

    /**
     * 設定當前值
     *
     * @param value
     */
    public void setValue(float value) {
        if (value > mMaxValue) {
            value = mMaxValue;
        }
        float start = mPercent;
        float end = value / mMaxValue;
        startAnimator(start, end, mAnimTime);
    }

    private void startAnimator(float start, float end, long animTime) {
        mAnimator.setDuration(animTime);
        mAnimator = ValueAnimator.ofFloat(start, end);
        mAnimator.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
            @Override
            public void onAnimationUpdate(ValueAnimator animation) {
                mPercent = (float) animation.getAnimatedValue();
                mValue = mPercent * mMaxValue;
                if (BuildConfig.DEBUG) {
                    Log.d(TAG, "onAnimationUpdate: percent = " + mPercent
                            + ";currentAngle = " + (mSweepAngle * mPercent)
                            + ";value = " + mValue);
                }
                invalidate();
            }
        });
        mAnimator.start();
    }

    /**
     * 獲取最大值
     *
     * @return
     */
    public float getMaxValue() {
        return mMaxValue;
    }

    /**
     * 設定最大值
     *
     * @param maxValue
     */
    public void setMaxValue(float maxValue) {
        mMaxValue = maxValue;
    }

    /**
     * 獲取精度
     *
     * @return
     */
    public int getPrecision() {
        return mPrecision;
    }

    public void setPrecision(int precision) {
        mPrecision = precision;
        mPrecisionFormat = getPrecisionFormat(precision);
    }

    public int[] getGradientColors() {
        return mGradientColors;
    }

    /**
     * 設定漸變
     *
     * @param gradientColors
     */
    public void setGradientColors(int[] gradientColors) {
        mGradientColors = gradientColors;
        updateArcPaint();
    }

    public long getAnimTime() {
        return mAnimTime;
    }

    public void setAnimTime(long animTime) {
        mAnimTime = animTime;
    }

    /**
     * 重置
     */
    public void reset() {
        startAnimator(mPercent, 0.0f, 1000L);
    }

    @Override
    protected void onDetachedFromWindow() {
        super.onDetachedFromWindow();
        //釋放資源
    }
}