/** 
* @FileName CircleProgressBar.java 
* @Package com.read.view 
* @Description TODO 
* @Author Alpha 
* @Date 2015-7-30 下午4:52:24  
* @Version V1.0 
 
*/ 
package com.read.view; 
import com.read.cnblogs.R; 
 
import android.animation.Animator; 
import android.animation.ObjectAnimator; 
import android.animation.ValueAnimator; 
import android.content.Context; 
import android.content.res.TypedArray; 
import android.graphics.Canvas; 
import android.graphics.Color; 
import android.graphics.ColorFilter; 
import android.graphics.Paint; 
import android.graphics.PixelFormat; 
import android.graphics.Rect; 
import android.graphics.RectF; 
import android.graphics.Paint.Cap; 
import android.util.AttributeSet; 
import android.util.Property; 
import android.view.View; 
import android.view.animation.AccelerateDecelerateInterpolator; 
import android.view.animation.Interpolator; 
import android.view.animation.LinearInterpolator; 
 
public class CircleProgressBar extends View { 
 
     private static final Interpolator ANGLE_INTERPOLATOR = new LinearInterpolator(); 
        private static final Interpolator SWEEP_INTERPOLATOR = new AccelerateDecelerateInterpolator(); 
        private static final int ANGLE_ANIMATOR_DURATION = 2000; 
        private static final int SWEEP_ANIMATOR_DURATION = 900; 
        private static final int MIN_SWEEP_ANGLE = 30; 
        private static final int DEFAULT_BORDER_WIDTH = 3; 
        private final RectF fBounds = new RectF(); 
 
        private ObjectAnimator mObjectAnimatorSweep; 
        private ObjectAnimator mObjectAnimatorAngle; 
        private boolean mModeAppearing = true; 
        private Paint mPaint; 
        private float mCurrentGlobalAngleOffset; 
        private float mCurrentGlobalAngle; 
        private float mCurrentSweepAngle; 
        private float mBorderWidth; 
        private boolean mRunning; 
        private int[] mColors; 
 
 
        public CircleProgressBar(Context context) { 
            this(context, null); 
        } 
 
        public CircleProgressBar(Context context, AttributeSet attrs) { 
            this(context, attrs, 0); 
        } 
 
        public CircleProgressBar(Context context, AttributeSet attrs, int defStyleAttr) { 
            super(context, attrs, defStyleAttr); 
 
            float density = context.getResources().getDisplayMetrics().density; 
            TypedArray a = context.obtainStyledAttributes(attrs, R.styleable.CircularProgress, defStyleAttr, 0); 
            mBorderWidth = a.getDimension(R.styleable.CircularProgress_borderWidth, 
                    DEFAULT_BORDER_WIDTH * density); 
            a.recycle(); 
             
            mColors = new int[2]; 
            mColors[0] = context.getResources().getColor(R.color.pink); 
            mPaint = new Paint(); 
            mPaint.setAntiAlias(true); 
            mPaint.setStyle(Paint.Style.STROKE); 
            mPaint.setStrokeCap(Cap.ROUND); 
            mPaint.setStrokeWidth(mBorderWidth); 
            mPaint.setColor(mColors[0]); 
 
            setupAnimations(); 
        } 
 
        private void start() { 
            if (mRunning) { 
                return; 
            } 
            mRunning = true; 
            mObjectAnimatorAngle.start(); 
            mObjectAnimatorSweep.start(); 
            invalidate(); 
        } 
 
        private void stop() { 
            if (!mRunning) { 
                return; 
            } 
            mRunning = false; 
            mObjectAnimatorAngle.cancel(); 
            mObjectAnimatorSweep.cancel(); 
            invalidate(); 
        } 
 
     
 
        @Override 
        protected void onVisibilityChanged(View changedView, int visibility) { 
            super.onVisibilityChanged(changedView, visibility); 
            if (visibility == VISIBLE) { 
                start(); 
            } else { 
                stop(); 
            } 
        } 
 
        @Override 
        protected void onAttachedToWindow() { 
            start(); 
            super.onAttachedToWindow(); 
        } 
 
        @Override 
        protected void onDetachedFromWindow() { 
            stop(); 
            super.onDetachedFromWindow(); 
        } 
        @Override 
        protected void onSizeChanged(int w, int h, int oldw, int oldh) { 
            super.onSizeChanged(w, h, oldw, oldh); 
            fBounds.left = mBorderWidth / 2f + .5f; 
            fBounds.right = w/2 - mBorderWidth / 2f - .5f; 
            fBounds.top = mBorderWidth / 2f + .5f; 
            fBounds.bottom = h/2 - mBorderWidth / 2f - .5f; 
        } 
 
        @Override 
        public void draw(Canvas canvas) { 
            super.draw(canvas); 
            float startAngle = mCurrentGlobalAngle - mCurrentGlobalAngleOffset; 
            float sweepAngle = mCurrentSweepAngle; 
            if (mModeAppearing) { 
                mPaint.setColor(mColors[0]); 
                sweepAngle += MIN_SWEEP_ANGLE; 
            } else { 
                startAngle = startAngle + sweepAngle; 
                sweepAngle = 360 - sweepAngle - MIN_SWEEP_ANGLE; 
            } 
            canvas.drawArc(fBounds, startAngle, sweepAngle, false, mPaint);//画弧线 
        } 
 
 
        private void toggleAppearingMode() { 
            mModeAppearing = !mModeAppearing; 
            if (mModeAppearing) { 
//                mCurrentColorIndex = ++mCurrentColorIndex % 4; 
//                mNextColorIndex = ++mNextColorIndex % 4; 
                mCurrentGlobalAngleOffset = (mCurrentGlobalAngleOffset + MIN_SWEEP_ANGLE * 2) % 360; 
            } 
        } 
        // //////////////////////////////////////////////////////////////////////////// 
        // ////////////// Animation 
 
        private Property<CircleProgressBar, Float> mAngleProperty = new Property<CircleProgressBar, Float>(Float.class, "angle") { 
            @Override 
            public Float get(CircleProgressBar object) { 
                return object.getCurrentGlobalAngle(); 
            } 
 
            @Override 
            public void set(CircleProgressBar object, Float value) { 
                object.setCurrentGlobalAngle(value); 
            } 
        }; 
 
        private Property<CircleProgressBar, Float> mSweepProperty = new Property<CircleProgressBar, Float>(Float.class, "arc") { 
            @Override 
            public Float get(CircleProgressBar object) { 
                return object.getCurrentSweepAngle(); 
            } 
 
            @Override 
            public void set(CircleProgressBar object, Float value) { 
                object.setCurrentSweepAngle(value); 
            } 
        }; 
 
        private void setupAnimations() { 
            mObjectAnimatorAngle = ObjectAnimator.ofFloat(this, mAngleProperty, 360f); 
            mObjectAnimatorAngle.setInterpolator(ANGLE_INTERPOLATOR); 
            mObjectAnimatorAngle.setDuration(ANGLE_ANIMATOR_DURATION); 
            mObjectAnimatorAngle.setRepeatMode(ValueAnimator.INFINITE); 
            mObjectAnimatorAngle.setRepeatCount(ValueAnimator.INFINITE); 
 
            mObjectAnimatorSweep = ObjectAnimator.ofFloat(this, mSweepProperty, 360f - MIN_SWEEP_ANGLE *2); 
            mObjectAnimatorSweep.setInterpolator(SWEEP_INTERPOLATOR); 
            mObjectAnimatorSweep.setDuration(SWEEP_ANIMATOR_DURATION); 
            mObjectAnimatorSweep.setRepeatMode(ValueAnimator.INFINITE); 
            mObjectAnimatorSweep.setRepeatCount(ValueAnimator.INFINITE); 
            mObjectAnimatorSweep.addListener(new Animator.AnimatorListener() { 
                @Override 
                public void onAnimationStart(Animator animation) { 
 
                } 
 
                @Override 
                public void onAnimationEnd(Animator animation) { 
 
                } 
 
                @Override 
                public void onAnimationCancel(Animator animation) { 
 
                } 
 
                @Override 
                public void onAnimationRepeat(Animator animation) { 
                    toggleAppearingMode(); 
                } 
            }); 
           
        } 
 
        public void setCurrentGlobalAngle(float currentGlobalAngle) { 
            mCurrentGlobalAngle = currentGlobalAngle; 
            invalidate(); 
        } 
 
        public float getCurrentGlobalAngle() { 
            return mCurrentGlobalAngle; 
        } 
 
        public void setCurrentSweepAngle(float currentSweepAngle) { 
            mCurrentSweepAngle = currentSweepAngle; 
            invalidate(); 
        } 
 
        public float getCurrentSweepAngle() { 
            return mCurrentSweepAngle; 
        } 
}