1，最近打开keep的app的时候，发现它的欢迎页面的倒计时效果还不错，所以打算自己来写写，然后就有了这篇文章。

2，还是老规矩，先看一下我们今天实现的效果

 　　相较于我们常见的倒计时，这次实现的效果是多了外面圆环的不断减少，这也是我们这次自定义view的有意思的一点。

 　　知道了效果我们先来效果分析一波，首先是一个倒计时效果，计时的时候上面的圆弧不断的减少，里面的文字也不断的变化，在视觉上的改变就大致为这两部分，但是实际上我们的ui是由三部分来构成的：里面的实心圆、外面的圆弧、里面的文字。知道了我们ui的组成，我们就来开撸开撸。

　　在开撸之前我们还是回顾一下我们简单的自定义view的基本流程

  1. /**
  2.  * 自定义View的几个步骤
  3.  * 1，自定义View属性
  4.  * 2，在View中获得我们的自定义的属性
  5.  * 3，重写onMeasure
  6.  * 4,重写onDraw
  7.  * 5，重写onLayout（这个决定view放置在哪儿）
  8.  */

　①、确定自定义属性

　　 我们根据上面的基本步骤，我们知道首先我们根据效果图先来确定我们这次的自定义属性，这里我简单的分析了一下，主要添加了八个自定义属性，分别是里面实心圆的半径和颜色、圆弧的颜色和半径、里面文字的大小和颜色、总倒计时时间的长度、圆弧减少的方向（分为顺时针和逆时针），所以首先在res/values目录下创建attrs.xml文件，添加以下属性:（这里如果有对自定义属性不太了解的同学可以去了解我以前写过的这篇文章，可以更加深刻的理解）

  1. <?xml version="1.0" encoding="utf-8"?>
  2. <resources>
  3.     <declare-styleable name="CircleTimerView">
  4.  
  5.         <attr name="solid_circle_radius" format="dimension"/>
  6.         <attr name="solid_circle_color" format="color"/>
  7.         <attr name="empty_circle_color" format="color"/>
  8.         <attr name="empty_circle_radius" format="dimension"/>
  9.         <attr name="circle_text_size" format="dimension"/>
  10.         <attr name="circle_text_color" format="color"/>
  11.  
  12.         <attr name="circle_draw_orientation" format="enum">
  13.             <!--顺时针-->
  14.             <enum name="clockwise" value="1"/>
  15.             <!--逆时针-->
  16.             <enum name="anticlockwise" value="2"/>
  17.         </attr>
  18.  
  19.         <attr name="time_length" format="integer"/>
  20.  
  21.     </declare-styleable>
  22. </resources>

　　②、获取自定义属性、初始化一些属性

　　首先创建CircleTimerView类，继承自View类

  1. public class CircleTimerView extends View {
  2.  
  3.     private Context context ;
  4.  
  5.     //里面实心圆颜色
  6.     private int mSolidCircleColor ;
  7.     //里面圆的半径
  8.     private int mSolidCircleRadius;
  9.     //外面圆弧的颜色
  10.     private int mEmptyCircleColor ;
  11.     //外面圆弧的半径(可以使用画笔的宽度来实现)
  12.     private int mEmptyCircleRadius ;
  13.     //文字大小
  14.     private int mTextSize ;
  15.     //文字颜色
  16.     private int mTextColor ;
  17.     //文字
  18.     private String mText ;
  19.     //绘制的方向
  20.     private int mDrawOrientation;
  21.     //圆弧绘制的速度
  22.     private int mSpeed;
  23.     //圆的画笔
  24.     private Paint mPaintCircle ;
  25.     //圆弧的画笔
  26.     private Paint mPaintArc ;
  27.     //绘制文字的画笔
  28.     private Paint mPaintText;
  29.     //时长
  30.     private int mTimeLength ;
  31.  
  32.     //默认值
  33.     private int defaultSolidCircleColor ;
  34.     private int defaultEmptyCircleColor ;
  35.     private int defaultSolidCircleRadius ;
  36.     private int defaultEmptyCircleRadius ;
  37.     private int defaultTextColor ;
  38.     private int defaultTextSize ;
  39.     private int defaultTimeLength ;
  40.     private int defaultDrawOritation ;
  41.  
  42.     //当前扇形的角度
  43.     private int startProgress ;
  44.     private int endProgress ;
  45.     private float currProgress ;
  46.  
  47.     //动画集合
  48.     private AnimatorSet set ;
  49.  
  50.     //回调
  51.     private OnCountDownFinish onCountDownFinish ;
  52.  
  53.     public CircleTimerView(Context context) {
  54.         this(context,null);
  55.     }
  56.  
  57.     public CircleTimerView(Context context, @Nullable AttributeSet attrs) {
  58.         this(context, attrs,0);
  59.     }
  60.  
  61.     public CircleTimerView(Context context, @Nullable AttributeSet attrs, int defStyleAttr) {
  62.         super(context, attrs, defStyleAttr);
  63.         this.context = context ;
  64.  
  65.         //初始化默认值
  66.         defaultSolidCircleColor = getResources().getColor(R.color.colorPrimary);
  67.         defaultEmptyCircleColor = getResources().getColor(R.color.colorAccent);
  68.         defaultTextColor = getResources().getColor(R.color.colorYellow);
  69.  
  70.         defaultSolidCircleRadius = (int) getResources().getDimension(R.dimen.dimen_20);
  71.         defaultEmptyCircleRadius = (int) getResources().getDimension(R.dimen.dimen_25);
  72.         defaultTextSize = (int) getResources().getDimension(R.dimen.dimen_16);
  73.  
  74.         defaultTimeLength = 3 ;
  75.         defaultDrawOritation = 1 ;
  76.  
  77.         //获取自定义属性
  78.         TypedArray a = context.obtainStyledAttributes(attrs, R.styleable.CircleTimerView);
  79.         mSolidCircleColor = a.getColor(R.styleable.CircleTimerView_solid_circle_color,defaultSolidCircleColor);
  80.         mSolidCircleRadius = a.getDimensionPixelOffset(R.styleable.CircleTimerView_solid_circle_radius ,defaultSolidCircleRadius);
  81.  
  82.         mEmptyCircleColor = a.getColor(R.styleable.CircleTimerView_empty_circle_color,defaultEmptyCircleColor);
  83.         mEmptyCircleRadius = a.getDimensionPixelOffset(R.styleable.CircleTimerView_empty_circle_radius ,defaultEmptyCircleRadius);
  84.  
  85.         mTextColor = a.getColor(R.styleable.CircleTimerView_circle_text_color,defaultTextColor);
  86.         mTextSize = a.getDimensionPixelOffset(R.styleable.CircleTimerView_circle_text_size ,defaultTextSize);
  87.  
  88.         mDrawOrientation = a.getInt(R.styleable.CircleTimerView_circle_draw_orientation,defaultDrawOritation);
  89.         mTimeLength = a.getInt(R.styleable.CircleTimerView_time_length ,defaultTimeLength);
  90.  
  91.         a.recycle();
  92.  
  93.         init();
  94.     }
  95.  
  96.     private void init() {
  97.         //初始化画笔
  98.         mPaintCircle = new Paint();
  99.         mPaintCircle.setStyle(Paint.Style.FILL);
  100.         mPaintCircle.setAntiAlias(true);
  101.         mPaintCircle.setColor(mSolidCircleColor);
  102.  
  103.         mPaintArc = new Paint();
  104.         mPaintArc.setStyle(Paint.Style.STROKE);
  105.         mPaintArc.setAntiAlias(true);
  106.         mPaintArc.setColor(mEmptyCircleColor);
  107.         mPaintArc.setStrokeWidth(mEmptyCircleRadius - mSolidCircleRadius);
  108.  
  109.         mPaintText = new Paint();
  110.         mPaintText.setStyle(Paint.Style.STROKE);
  111.         mPaintText.setAntiAlias(true);
  112.         mPaintText.setTextSize(mTextSize);
  113.         mPaintText.setColor(mTextColor);
  114.  
  115.         mText= mTimeLength +"" ;
  116.         if(defaultDrawOritation == 1){
  117.             startProgress = 360 ;
  118.             endProgress = 0 ;
  119.         }else {
  120.             startProgress = 0 ;
  121.             endProgress = 360 ;
  122.         }
  123.         currProgress = startProgress ;
  124.     }

　　这里我在构造函数里面先初始化一些默认的值，然后获取自定义属性，然后再初始化三个画笔，分别代表：实心圆、圆弧、Text的画笔（这个很好理解），然后根据顺时针和逆时针来初始化开始角度和结束角度，很简单就不在过多的废话了。

　　③、重写onMeasure方法

　　这里由于我们的效果很简单，基本上就是一个正方形，所以这里我是以外面圆弧的半径当这个view 的宽高的，就没去判断match_parent、wrap_content之类的情况，代码如下：

  1. @Override
  2.     protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
  3.         super.onMeasure(widthMeasureSpec, heightMeasureSpec);
  4.         //设置宽高
  5.         setMeasuredDimension(mEmptyCircleRadius*2,mEmptyCircleRadius*2);
  6.     }

　　④，重写onDraw方法

　　这也是我们自定义view关键，首先我们绘制圆弧和文字很简单，绘制圆弧的话可能有些同学没有接触过，这里我以前写过一篇，大家可以去看看，我们这里要用的知识点 都是一样的，所以就不再废话

　　

  1. @Override
  2.     protected void onDraw(Canvas canvas) {
  3.         super.onDraw(canvas);
  4.         //绘制背景圆
  5.         canvas.drawCircle(mEmptyCircleRadius,mEmptyCircleRadius,mSolidCircleRadius,mPaintCircle);
  6.  
  7.         //绘制圆弧
  8.         RectF oval = new RectF((mEmptyCircleRadius - mSolidCircleRadius)/2, (mEmptyCircleRadius - mSolidCircleRadius)/2
  9.                 , mEmptyCircleRadius + (mEmptyCircleRadius - mSolidCircleRadius)/2+mSolidCircleRadius, mEmptyCircleRadius + (mEmptyCircleRadius - mSolidCircleRadius)/2+mSolidCircleRadius); // 用于定义的圆弧的形状和大小的界限
  10.  
  11.         canvas.drawArc(oval, -90, currProgress, false, mPaintArc); // 根据进度画圆弧
  12.  
  13.         //绘制文字
  14.         Rect mBound = new Rect();
  15.         mPaintText.getTextBounds(mText, 0, mText.length(), mBound);
  16.         canvas.drawText(mText, getWidth() / 2 - mBound.width() / 2, getHeight() / 2 + mBound.height() / 2, mPaintText);
  17.     }

　　在这个时候，我们就可以来看一下我们自定义view的效果了，将我们currProgress先写死成270，来看看我们的效果，这里注意一项在使用我们的自定义属性的时候，记得在布局文件中添加我们自定义空间。运行效果如下：

　　可以看到这里我们的效果基本上试出来了，关键是怎么让它动起来，这里我们的第一反应是handle或者timer来实现一个倒计时，一开始阿呆哥哥也是使用timer来实现的，不过发现由于ui的改变中是有两个不同速率的view在改变：圆弧的不断减小、textView字体的逐渐变小，所以这里使用一个timer无法实现，得用两个，如果用两个就不怎么软件工程了，所以这里打算使用动画来实现，具体代码如下：

  1. /**
  2.      * 通过外部开关控制
  3.      */
  4.     public void start(){
  5.        
  6.         ValueAnimator animator1 = ValueAnimator.ofFloat(startProgress,endProgress);
  7.         animator1.setInterpolator(new LinearInterpolator());
  8.         animator1.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
  9.             @Override
  10.             public void onAnimationUpdate(ValueAnimator valueAnimator) {
  11.                 currProgress = (float) valueAnimator.getAnimatedValue();
  12.                 invalidate();
  13.             }
  14.         });
  15.  
  16.         ValueAnimator animator2 = ValueAnimator.ofInt(mTimeLength,0);
  17.         animator2.setInterpolator(new LinearInterpolator());
  18.         animator2.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
  19.             @Override
  20.             public void onAnimationUpdate(ValueAnimator valueAnimator) {
  21.                 mTimeLength = (int) valueAnimator.getAnimatedValue();
  22.                 if (mTimeLength == 0)
  23.                     return;
  24.                 mText =mTimeLength+ "";
  25.             }
  26.         });
  27.  
  28.         set = new AnimatorSet();
  29.         set.playTogether(animator1,animator2);
  30.         set.setDuration(mTimeLength * 1000);
  31.  
  32.         set.start();
  33.  
  34.         set.addListener(new Animator.AnimatorListener() {
  35.             @Override
  36.             public void onAnimationStart(Animator animator) {
  37.  
  38.             }
  39.  
  40.             @Override
  41.             public void onAnimationEnd(Animator animator) {
  42.                 if (onCountDownFinish != null){
  43.                     onCountDownFinish.onFinish();
  44.                 }
  45.             }
  46.  
  47.             @Override
  48.             public void onAnimationCancel(Animator animator) {
  49.  
  50.             }
  51.  
  52.             @Override
  53.             public void onAnimationRepeat(Animator animator) {
  54.  
  55.             }
  56.         });
  57.  
  58.  
  59.     }

　　很简单，就是两个ValueAnimator，监听值的改变，然后再最后完成的动画的时候使用接口回调，通知宿主完成ToDo操作，所以到这里我们基本上完全实现了我们的view 的自定义，CircleTimerView的完整代码如下：

  1. package com.ysten.circletimerdown.view;
  2.  
  3.  
  4. import android.animation.Animator;
  5. import android.animation.AnimatorSet;
  6. import android.animation.ValueAnimator;
  7. import android.content.Context;
  8. import android.content.res.TypedArray;
  9. import android.graphics.Canvas;
  10. import android.graphics.Paint;
  11. import android.graphics.Rect;
  12. import android.graphics.RectF;
  13. import android.support.annotation.Nullable;
  14. import android.util.AttributeSet;
  15. import android.view.View;
  16. import android.view.animation.AnimationSet;
  17. import android.view.animation.LinearInterpolator;
  18.  
  19. import com.ysten.circletimerdown.R;
  20.  
  21. import java.util.Timer;
  22. import java.util.TimerTask;
  23.  
  24.  
  25. /**
  26.  * author : wangjitao
  27.  * e-mail : 543441727@qq.com
  28.  * time   : 2017/08/14
  29.  * desc   :
  30.  * version: 1.0
  31.  */
  32. public class CircleTimerView extends View {
  33.  
  34.     private Context context ;
  35.  
  36.     //里面实心圆颜色
  37.     private int mSolidCircleColor ;
  38.     //里面圆的半径
  39.     private int mSolidCircleRadius;
  40.     //外面圆弧的颜色
  41.     private int mEmptyCircleColor ;
  42.     //外面圆弧的半径(可以使用画笔的宽度来实现)
  43.     private int mEmptyCircleRadius ;
  44.     //文字大小
  45.     private int mTextSize ;
  46.     //文字颜色
  47.     private int mTextColor ;
  48.     //文字
  49.     private String mText ;
  50.     //绘制的方向
  51.     private int mDrawOrientation;
  52.     //圆弧绘制的速度
  53.     private int mSpeed;
  54.     //圆的画笔
  55.     private Paint mPaintCircle ;
  56.     //圆弧的画笔
  57.     private Paint mPaintArc ;
  58.     //绘制文字的画笔
  59.     private Paint mPaintText;
  60.     //时长
  61.     private int mTimeLength ;
  62.  
  63.     //默认值
  64.     private int defaultSolidCircleColor ;
  65.     private int defaultEmptyCircleColor ;
  66.     private int defaultSolidCircleRadius ;
  67.     private int defaultEmptyCircleRadius ;
  68.     private int defaultTextColor ;
  69.     private int defaultTextSize ;
  70.     private int defaultTimeLength ;
  71.     private int defaultDrawOritation ;
  72.  
  73.     //当前扇形的角度
  74.     private int startProgress ;
  75.     private int endProgress ;
  76.     private float currProgress ;
  77.  
  78.     //动画集合
  79.     private AnimatorSet set ;
  80.  
  81.     //回调
  82.     private OnCountDownFinish onCountDownFinish ;
  83.  
  84.     public CircleTimerView(Context context) {
  85.         this(context,null);
  86.     }
  87.  
  88.     public CircleTimerView(Context context, @Nullable AttributeSet attrs) {
  89.         this(context, attrs,0);
  90.     }
  91.  
  92.     public CircleTimerView(Context context, @Nullable AttributeSet attrs, int defStyleAttr) {
  93.         super(context, attrs, defStyleAttr);
  94.         this.context = context ;
  95.  
  96.         //初始化默认值
  97.         defaultSolidCircleColor = getResources().getColor(R.color.colorPrimary);
  98.         defaultEmptyCircleColor = getResources().getColor(R.color.colorAccent);
  99.         defaultTextColor = getResources().getColor(R.color.colorYellow);
  100.  
  101.         defaultSolidCircleRadius = (int) getResources().getDimension(R.dimen.dimen_20);
  102.         defaultEmptyCircleRadius = (int) getResources().getDimension(R.dimen.dimen_25);
  103.         defaultTextSize = (int) getResources().getDimension(R.dimen.dimen_16);
  104.  
  105.         defaultTimeLength = 3 ;
  106.         defaultDrawOritation = 1 ;
  107.  
  108.         //获取自定义属性
  109.         TypedArray a = context.obtainStyledAttributes(attrs, R.styleable.CircleTimerView);
  110.         mSolidCircleColor = a.getColor(R.styleable.CircleTimerView_solid_circle_color,defaultSolidCircleColor);
  111.         mSolidCircleRadius = a.getDimensionPixelOffset(R.styleable.CircleTimerView_solid_circle_radius ,defaultSolidCircleRadius);
  112.  
  113.         mEmptyCircleColor = a.getColor(R.styleable.CircleTimerView_empty_circle_color,defaultEmptyCircleColor);
  114.         mEmptyCircleRadius = a.getDimensionPixelOffset(R.styleable.CircleTimerView_empty_circle_radius ,defaultEmptyCircleRadius);
  115.  
  116.         mTextColor = a.getColor(R.styleable.CircleTimerView_circle_text_color,defaultTextColor);
  117.         mTextSize = a.getDimensionPixelOffset(R.styleable.CircleTimerView_circle_text_size ,defaultTextSize);
  118.  
  119.         mDrawOrientation = a.getInt(R.styleable.CircleTimerView_circle_draw_orientation,defaultDrawOritation);
  120.         mTimeLength = a.getInt(R.styleable.CircleTimerView_time_length ,defaultTimeLength);
  121.  
  122.         a.recycle();
  123.  
  124.         init();
  125.     }
  126.  
  127.     private void init() {
  128.         //初始化画笔
  129.         mPaintCircle = new Paint();
  130.         mPaintCircle.setStyle(Paint.Style.FILL);
  131.         mPaintCircle.setAntiAlias(true);
  132.         mPaintCircle.setColor(mSolidCircleColor);
  133.  
  134.         mPaintArc = new Paint();
  135.         mPaintArc.setStyle(Paint.Style.STROKE);
  136.         mPaintArc.setAntiAlias(true);
  137.         mPaintArc.setColor(mEmptyCircleColor);
  138.         mPaintArc.setStrokeWidth(mEmptyCircleRadius - mSolidCircleRadius);
  139.  
  140.         mPaintText = new Paint();
  141.         mPaintText.setStyle(Paint.Style.STROKE);
  142.         mPaintText.setAntiAlias(true);
  143.         mPaintText.setTextSize(mTextSize);
  144.         mPaintText.setColor(mTextColor);
  145.  
  146.         mText= mTimeLength +"" ;
  147.         if(defaultDrawOritation == 1){
  148.             startProgress = 360 ;
  149.             endProgress = 0 ;
  150.         }else {
  151.             startProgress = 0 ;
  152.             endProgress = 360 ;
  153.         }
  154.         currProgress = startProgress ;
  155.     }
  156.  
  157.     @Override
  158.     protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
  159.         super.onMeasure(widthMeasureSpec, heightMeasureSpec);
  160.         //设置宽高
  161.         setMeasuredDimension(mEmptyCircleRadius*2,mEmptyCircleRadius*2);
  162.     }
  163.  
  164.     @Override
  165.     protected void onDraw(Canvas canvas) {
  166.         super.onDraw(canvas);
  167.         //绘制背景圆
  168.         canvas.drawCircle(mEmptyCircleRadius,mEmptyCircleRadius,mSolidCircleRadius,mPaintCircle);
  169.  
  170.         //绘制圆弧
  171.         RectF oval = new RectF((mEmptyCircleRadius - mSolidCircleRadius)/2, (mEmptyCircleRadius - mSolidCircleRadius)/2
  172.                 , mEmptyCircleRadius + (mEmptyCircleRadius - mSolidCircleRadius)/2+mSolidCircleRadius, mEmptyCircleRadius + (mEmptyCircleRadius - mSolidCircleRadius)/2+mSolidCircleRadius); // 用于定义的圆弧的形状和大小的界限
  173.  
  174.         canvas.drawArc(oval, -90, currProgress, false, mPaintArc); // 根据进度画圆弧
  175.  
  176.         //绘制文字
  177.         Rect mBound = new Rect();
  178.         mPaintText.getTextBounds(mText, 0, mText.length(), mBound);
  179.         canvas.drawText(mText, getWidth() / 2 - mBound.width() / 2, getHeight() / 2 + mBound.height() / 2, mPaintText);
  180.     }
  181.  
  182.     public OnCountDownFinish getOnCountDownFinish() {
  183.         return onCountDownFinish;
  184.     }
  185.  
  186.     public void setOnCountDownFinish(OnCountDownFinish onCountDownFinish) {
  187.         this.onCountDownFinish = onCountDownFinish;
  188.     }
  189.  
  190.  
  191.     /**
  192.      * 通过外部开关控制
  193.      */
  194.     public void start(){
  195.  
  196.         ValueAnimator animator1 = ValueAnimator.ofFloat(startProgress,endProgress);
  197.         animator1.setInterpolator(new LinearInterpolator());
  198.         animator1.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
  199.             @Override
  200.             public void onAnimationUpdate(ValueAnimator valueAnimator) {
  201.                 currProgress = (float) valueAnimator.getAnimatedValue();
  202.                 invalidate();
  203.             }
  204.         });
  205.  
  206.         ValueAnimator animator2 = ValueAnimator.ofInt(mTimeLength,0);
  207.         animator2.setInterpolator(new LinearInterpolator());
  208.         animator2.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
  209.             @Override
  210.             public void onAnimationUpdate(ValueAnimator valueAnimator) {
  211.                 mTimeLength = (int) valueAnimator.getAnimatedValue();
  212.                 if (mTimeLength == 0)
  213.                     return;
  214.                 mText =mTimeLength+ "";
  215.             }
  216.         });
  217.  
  218.         set = new AnimatorSet();
  219.         set.playTogether(animator1,animator2);
  220.         set.setDuration(mTimeLength * 1000);
  221.  
  222.         set.start();
  223.  
  224.         set.addListener(new Animator.AnimatorListener() {
  225.             @Override
  226.             public void onAnimationStart(Animator animator) {
  227.  
  228.             }
  229.  
  230.             @Override
  231.             public void onAnimationEnd(Animator animator) {
  232.                 if (onCountDownFinish != null){
  233.                     onCountDownFinish.onFinish();
  234.                 }
  235.             }
  236.  
  237.             @Override
  238.             public void onAnimationCancel(Animator animator) {
  239.  
  240.             }
  241.  
  242.             @Override
  243.             public void onAnimationRepeat(Animator animator) {
  244.  
  245.             }
  246.         });
  247.  
  248.  
  249.     }
  250.  
  251.     public void cancelAnim(){
  252.         if(set != null)
  253.         set.pause();
  254.     }
  255.  
  256.     public interface OnCountDownFinish{
  257.         void onFinish();
  258.     }
  259. }

　　最后实现的效果如下：

    Github代码地址，有需要源码的同学可以去下载一下。

版权声明：本文为wjtaigwh原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://www.cnblogs.com/wjtaigwh/p/7359114.html