自定义progress

package com.example.yangzhelin.myprogressbar;

import android.content.Context;
import android.content.res.TypedArray;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.graphics.RectF;
import android.os.Handler;
import android.text.TextUtils;
import android.util.AttributeSet;
import android.view.View;
import android.view.WindowManager;
import android.widget.Toast;


/**
 * Created by yangzhelin on 2016/8/26.
 */
public class HaloveProgressBar extends View {
    private Paint mPaintCircle;
    private Paint mPaintHead;
    private Paint mPaintArc;

    private float startAngle;
    private float startOffest;
    private int mWidth;
    private int mHeight;
    private RectF rectF;
    private int windowHeight;

    private int paintWidth;
    private int speed ;
    private String yColor ;
    private int windowWidth;
    private Context mContext;

    private int paddingTop;
    private int paddingBottom;
    private int paddingLeft;
    private int paddingRight;

    private float rectFLeft;
    private float rectFTop;
    private float rectFRight;
    private float rectFBottom;
    //当设置padding的一个按钮
    private boolean isDrawCircle;
    //当用户需要设置内边距厚度的时候的一个按钮
    private boolean setPaintWidth;

    private final static String START_COLOR="#FEDA14";
    private final static int START_SPEED=60;
    private final static int START_PAINTWIDTH=40;
    private final static int ACCOUNTED_FOR_FOUR=4;
    private final static int MIN=1;
    private final static int SCALE=2;
    private final static float DEVIATION_CIRCLE_ARC=1.5f;
    private final static float DEVIATION_HEAD=0.5f;
    private final static float STARTANGLE=220f;
    private final static float STARTOFFEST=-5f;
    private final static int CRITICALITY_VALUE=0;
    private final static int ROUND_DEGREE=360;
    private final static float ARC_PASS=20f;
    private final static float ARC_INCREASE=10f;

    public int getPaintWidth() {
        return paintWidth;
    }

    public int getSpeed() {
        return speed;
    }

    public String getyColor() {
        return yColor;
    }

    public void setyColor(String yColor) {
        if (!TextUtils.isEmpty(yColor)) {
            this.yColor = yColor;
            if(mPaintHead!=null&&mPaintCircle!=null){
                mPaintCircle.setColor(Color.parseColor(yColor));
                mPaintHead.setColor(Color.parseColor(yColor));
            }

        } else {
            this.yColor = START_COLOR;
        }
        overSet(true);
    }


    /**
     *
     * @param paintWidth 宽度(不超过直径的25%)
     */
    public void setPaintWidth(int paintWidth) {
        if (paintWidth <=(mWidth/ACCOUNTED_FOR_FOUR) && paintWidth > CRITICALITY_VALUE) {
            this.paintWidth = paintWidth;
        } else if (paintWidth> mWidth/ACCOUNTED_FOR_FOUR) {
            this.paintWidth = mWidth/ACCOUNTED_FOR_FOUR;
        } else {
            this.paintWidth = MIN;
        }
        setPaintWidth=false;
        if(mPaintArc!=null&&mPaintCircle!=null&&mPaintArc!=null){
            mPaintCircle.setStrokeWidth(paintWidth -DEVIATION_CIRCLE_ARC);
            mPaintHead.setStrokeWidth((float) (paintWidth - DEVIATION_HEAD));
            mPaintArc.setStrokeWidth(paintWidth+DEVIATION_CIRCLE_ARC);
        }
        overSet(true);
    }

    public void setSpeed(int speed) {
        if (speed > CRITICALITY_VALUE) {
            this.speed = speed;
        } else {
            this.speed = MIN;
        }

    }

    public HaloveProgressBar(Context context) {
        super(context);
        init(context);
    }
    public HaloveProgressBar(Context context, AttributeSet attrs) {
        super(context, attrs);
        TypedArray a = context.obtainStyledAttributes(attrs, R.styleable.HaloveProgress);
        speed = a.getInteger(R.styleable.HaloveProgress_mSpeed, START_SPEED);
        paintWidth = a.getInteger(R.styleable.HaloveProgress_mThickness, START_PAINTWIDTH);
        yColor = a.getString(R.styleable.HaloveProgress_mColor);
        setyColor(yColor);
        init(context);
    }

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



    private void init(Context context) {
        startAngle=STARTANGLE;
        startOffest=STARTOFFEST;
        mContext = context;
        mPaintCircle = new Paint();
        mPaintCircle.setAntiAlias(true);
        mPaintCircle.setColor(Color.parseColor(yColor));
        mPaintCircle.setStyle(Paint.Style.STROKE);
        mPaintCircle.setStrokeCap(Paint.Cap.ROUND);
        mPaintCircle.setStrokeWidth(paintWidth -DEVIATION_CIRCLE_ARC);
        mPaintHead=new Paint();
        mPaintHead.setAntiAlias(true);
        mPaintHead.setStyle(Paint.Style.STROKE);
        mPaintHead.setStrokeCap(Paint.Cap.ROUND);
        mPaintHead.setColor(Color.parseColor(yColor));
        mPaintHead.setStrokeWidth((float) (paintWidth - DEVIATION_HEAD));
        mPaintArc=new Paint();
        mPaintArc.setAntiAlias(true);
        mPaintArc.setStyle(Paint.Style.STROKE);
        mPaintArc.setStrokeCap(Paint.Cap.ROUND);
        mPaintArc.setColor(Color.WHITE);
        mPaintArc.setStrokeWidth(paintWidth+DEVIATION_CIRCLE_ARC);
        WindowManager wm = (WindowManager) context
                .getSystemService(Context.WINDOW_SERVICE);
        windowWidth = wm.getDefaultDisplay().getWidth();
        windowHeight = wm.getDefaultDisplay().getHeight();
        if (windowWidth > windowHeight) {
            windowWidth = windowHeight;
        }
    }

    @Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        int widthMode = MeasureSpec.getMode(widthMeasureSpec);
        int width = MeasureSpec.getSize(widthMeasureSpec);
        int heightMode = MeasureSpec.getMode(heightMeasureSpec);
        int height = MeasureSpec.getSize(heightMeasureSpec);
        if (width != height) {
            if (width > height) {
                width = height;
            }
        }
        int width2= measureWidth(widthMode,width);
        setMeasuredDimension(width2, measureHeight(heightMode,height));

    }

    private int measureWidth(int mode, int width) {
        switch (mode) {
            case MeasureSpec.UNSPECIFIED:
                break;
            case MeasureSpec.AT_MOST:
                break;
            case MeasureSpec.EXACTLY:
                if((width/ACCOUNTED_FOR_FOUR)>=paintWidth){
                    mWidth=width;
                } else if (width>=windowWidth) {
                    mWidth = windowWidth;

                } else {
                    mWidth = ACCOUNTED_FOR_FOUR*paintWidth;
                }

                break;

        }
        return mWidth;
    }
    private int measureHeight(int mode, int height) {
        switch (mode) {
            case MeasureSpec.UNSPECIFIED:
                break;
            case MeasureSpec.AT_MOST:
                mHeight = mWidth;
                break;
            case MeasureSpec.EXACTLY:
                if(height/ACCOUNTED_FOR_FOUR>=paintWidth){
                    mHeight = height;
                }else if(height>=windowHeight){
                    mHeight=windowHeight;
                }else{
                    mHeight=ACCOUNTED_FOR_FOUR*paintWidth;
                }

                break;

        }
        return mHeight;
    }

    @Override
    protected void onSizeChanged(int w, int h, int oldw, int oldh) {
        super.onSizeChanged(w, h, oldw, oldh);
        paddingTop=getPaddingTop();
        paddingBottom= getPaddingBottom();
        paddingLeft=getPaddingLeft();
        paddingRight=getPaddingRight();
        if(paddingTop==paddingBottom&&paddingTop==paddingLeft&&paddingTop==paddingRight){
            isDrawCircle=true;
        }


    }

    private Handler handler = new Handler();
    private boolean isRuning;

    public boolean isRuning() {
        return isRuning;
    }

    public void setRuning(boolean runing) {
        isRuning = runing;
        overSet(false);
    }

    private void overSet(boolean b) {
        if (isRuning == b) invalidate();
    }

    @Override
    protected void onDraw(Canvas canvas) {
        if(rectF==null||!setPaintWidth){
            if(isDrawCircle){
                rectFLeft=paintWidth/SCALE+paddingLeft;
                rectFTop=paintWidth/SCALE+paddingTop;
                rectFRight=mWidth-((paintWidth/SCALE))-paddingRight;
                rectFBottom=mWidth - ((paintWidth/SCALE))-paddingBottom;
            }else{
                rectFLeft=paintWidth/SCALE+paddingLeft-paddingRight;
                rectFTop=paintWidth/SCALE+paddingTop-paddingBottom;
                rectFRight=mWidth-((paintWidth/SCALE)-paddingLeft)-paddingRight;
                rectFBottom=mWidth - ((paintWidth/SCALE)-paddingTop )-paddingBottom;
            }
            rectF = new RectF(rectFLeft, rectFTop, rectFRight, rectFBottom);
            setPaintWidth=true;
        }
        canvas.drawOval(rectF,mPaintCircle);

        canvas.drawArc(rectF, startAngle, startOffest, false, mPaintArc);

        canvas.drawArc(rectF, startAngle, MIN, false, mPaintHead);
        if (!isRuning) {
            overDraw();
        }

    }

    //判断是否是第一圈
    private boolean isFrist;
    private void overDraw() {
        handler.postDelayed(new Runnable() {
            @Override
            public void run() {
                startAngle-=ARC_PASS;
                if(startAngle<=CRITICALITY_VALUE){
                    startAngle=ROUND_DEGREE+startAngle;
                }if(!isFrist){
                    startOffest-=ARC_INCREASE;
                }else{
                    startOffest+=ARC_INCREASE;
                }
                if(startAngle==STARTANGLE){
                    isFrist=!isFrist;
                }
                invalidate();
            }
        }, speed);
    }


}