一、简介

最近开始写一些文章记录一下以前的一些自己写的小项目或者是定义View积累，积灰的东西还是要多翻出来整理整理看看的。这个只完成了一部分燃起熄灭的动画，没有为何燃起火焰的动画，希望有兴趣的同学也可以接着完成并分享，话不多说，我们来看这两根萌萌的小蜡烛。

小蜡烛憋足气把火焰燃起，一下被旁边的哥们吹灭了 0^0 ,看起来还是萌气十足的啊。看着图大家应该能想到应该怎么实现了吧，自定义View!对了，但是具体要怎么把这个过程做好呢，跟着脚步一起来看一看吧。代码稍微有点多，大家耐心观看，有兴趣的同学可以从我的GITHUB上clone下来，对着代码看。

二、过程实现

蜡烛的绘制和动画

• 本着面向对象的思想，很明显这里就是两个蜡烛嘛!既然是这样那我们就定义一个蜡烛类具有蜡烛的基本属性。 

1. public abstract class ICandle { 
2.  
3.  
4.     //蜡烛底部左下坐标 
5.  
6.     protected int mCurX; 
7.  
8.     protected int mCurY; 
9.  
10.     //蜡烛宽高 
11.  
12.     protected int mCandleWidth; 
13.  
14.     protected int mCandleHeight; 
15.  
16.     //蜡烛左眼坐标 
17.  
18.     protected Point mEyeLPoint; 
19.  
20.     //蜡烛右眼坐标 
21.  
22.     protected Point mEyeRPoint; 
23.  
24.     //蜡烛眼睛半径 
25.  
26.     protected int mEyeRadius; 
27.  
28.     //眼睛间隔距离 
29.  
30.     protected int mEyeDevide; 
31.  
32.     //身体颜色 
33.  
34.     protected int mCandleColor; 
35.  
36.     //是否停止动画中 
37.  
38.     protected boolean mIsAnimStoping = false; 
39.  
40.     //蜡烛芯坐标 
41.  
42.     protected Point mCandlewickPoint; 
43.  
44.     public void initAnim(){ 
45.  
46.     } 
47.  
48.     public void stopAnim(){ 
49.  
50.     } 
51.  
52.     public void drawSelf(Canvas canvas){ 
53.  
54.     } 
55.  
56. } 

对应着这蜡烛还有代码，那就一目了然了。可能需要解释的应该就是下面的几个方法了public void initAnim()， stopAnim()初始化开始和结束动画需要的数据，小蜡烛将会实现这个方法，drawSelf(Canvas canvas)把画布传进来然后蜡烛自己绘制自己。

现在就是让我们来看一看小蜡烛身体内部构造的时候了，hiahiahiahia!

不对，和蜡烛生死相随的还有火焰呢!先来看看火焰吧，等下小蜡烛还要燃烧自己呢。+10086s

Flame

• 一样先来一睹我们的富勒姆真容 

好像也没什么毛病，首先是里面的区域，就是Flame啦，外面的呢，就是Flame先生燃烧自己散发的人性之光和飘散的骨灰(手动抹眼泪)。

来看一下Flame的实现吧。我们一步步分析。

1. private static float CHANGE_FACTOR = 20; 
2.  
3.    private Paint mPaint; 
4.  
5.    private Path mPath; 
6.  
7.    //左下点坐标 
8.  
9.    private int mCurX; 
10.  
11.    private int mCurY; 
12.  
13.    //火焰宽度 
14.  
15.    private int mWidth; 
16.  
17.    //火焰高度 
18.  
19.    private int mHeight; 
20.  
21.    //记录初始高度 
22.  
23.    private int mPreHeight; 
24.  
25.    //记录初始宽度 
26.  
27.    private int mPreWidth; 
28.  
29.    //火焰顶部贝塞尔曲线控制点变化参数 
30.  
31.    private int mTopXFactor; 
32.  
33.    private int mTopYFactor; 
34.  
35.    //用于实现火焰的抖动 
36.  
37.    private Random mRandom; 
38.  
39.    //光环半径 
40.  
41.    private int mHaloRadius; 
42.  
43.    //正在燃烧 
44.  
45.    private boolean mIsFiring; 
46.  
47.    //是否启动停止动画 
48.  
49.    private boolean mIsStopAnim = false; 
50.  
51.    private boolean mFlagStop = false; 
52.  
53.    private LinearGradient mLinearGradient; 
54.  
55.    private RadialGradient mRadialGradient; 
56.  
57.    private ValueAnimator mFlameAnimator; 
58.  
59.    private ValueAnimator mHaloAnimator; 

参数就是这些了，主要是我们的动画实现过程，也就是我们的属性动画ValueAnimator这里还有两个渲染类不知道大家用过没有，LinearGradient和RadialGradient不了解的同学可以直接点我的博文了解一下。LinearGradient绘制出了火焰，RadialGradient绘制除了发散的光芒。

初始化的过程我就不写了，大家对这代码看吧。那主要的就是小火焰的是怎么绘制出来的呢 show the code

1. mPaint.setStyle(Paint.Style.FILL); 
2.  
3.    mPaint.setShader(mLinearGradient); 
4.  
5.    mPath.reset(); 
6.  
7.    mPath.moveTo(mCurX, mCurY); 
8.  
9.    mPath.quadTo(mCurX + mWidth / 2, 
10.  
11.            mCurY + mHeight / 3, 
12.  
13.            mCurX + mWidth, mCurY); 
14.  
15.    mPath.quadTo(mCurX + mWidth / 2 + ((1 - mRandom.nextFloat()) * CHANGE_FACTOR) + mTopXFactor, 
16.  
17.            mCurY - 2 * mHeight + mTopYFactor, 
18.  
19.            mCurX, mCurY); 
20.  
21.    canvas.drawPath(mPath, mPaint); 

这就是火焰flame的绘制，可以看到这里用到了二次贝塞尔曲线的绘制，不太清楚贝塞尔曲线的同学也可以点这波浪Loading动画(贝塞尔曲线)有简单的介绍，当时是用在一个水波的view里面。这里的绘制是以前面那个图里面的矩形为参照，我们再来看一下这个图(当然是加强版hiahia)。

那为什么上面的x坐标还加了mRandom.nextFloat()) * CHANGE_FACTOR呢?你想啊，火焰不是会左右晃动吗，利用一个随机来控制左右摆动咯。

1. mFlameAnimator = ValueAnimator.ofFloat(0, 4).setDuration(4000); 
2.  
3.    mFlameAnimator.setRepeatCount(ValueAnimator.INFINITE); 
4.  
5.    mFlameAnimator.addUpdateListener( 
6.  
7.                   new ValueAnimator.AnimatorUpdateListener() { 
8.  
9.        @Override 
10.  
11.        public void onAnimationUpdate(ValueAnimator animation) { 
12.  
13.            float zeroToOne = (float) animation.getAnimatedValue(); 
14.  
15.            if (zeroToOne >= 1.0f && zeroToOne <= 1.2f) { 
16.  
17.                //火焰燃起 
18.  
19.                zeroToOne = 1.0f - 5 * (zeroToOne - 1.0f);//1-0 
20.  
21.                mHeight = (int) (mPreHeight * (1 - zeroToOne)); 
22.  
23.                mIsFiring = true; 
24.  
25.            } else if (zeroToOne >= 3.5f) { 
26.  
27.                if (mFlagStop) { 
28.  
29.                    mFlameAnimator.cancel(); 
30.  
31.                    return; 
32.  
33.                } 
34.  
35.                //火焰被吹灭 
36.  
37.                zeroToOne = 2 * (zeroToOne - 3.5f);//0-2 
38.  
39.                mTopXFactor = (int) (-20 * zeroToOne); 
40.  
41.                mTopYFactor = (int) (160 * zeroToOne); 
42.  
43. /                    mWidth = (int) (mPreWidth * (1 -zeroToOne)); 
44.  
45.                mIsFiring = false; 
46.  
47.            } 
48.  
49.        } 
50.  
51.    });  

在4秒的时间内，火焰进行了一系列活动，从下面随着灯芯移上来，不断的改变火焰的位置，分为了两部分，火焰燃起和火焰熄灭，从代码中可以看到，火焰燃起时mHeight慢慢变大，然后就是有了升起的过程辣，另外一个就是火焰被吹灭的时候，因为吹灭的时候火焰的高度肯定是保持之前的值，所以不需要改变，而是用了mTopXFactor和mTopYFactor这个两个因子来控制火焰的位置。好了，既然火焰有了，蜡炬成灰泪始干啊，生命之光也该出场了。

光圈的绘制和动画就相对简单了

1. mPaint.setStyle(Paint.Style.STROKE); 
2.  
3.            mPaint.setStrokeWidth(5); 
4.  
5.            mPaint.setShader(mRadialGradient); 
6.  
7.            canvas.drawCircle(mCurX + mWidth / 2, 
8.  
9.                         mCurY - mHeight / 2, mHaloRadius, mPaint); 
10.  
11.            canvas.drawCircle(mCurX + mWidth / 2, 
12.  
13.                         mCurY - mHeight / 2, mHaloRadius + 5, mPaint); 
14.  
15.            canvas.drawCircle(mCurX + mWidth / 2, 
16.  
17.                         mCurY - mHeight / 2, mHaloRadius - 5, mPaint);  

这里改变的只有一个参数，mHaloRadius也就是光圈的半径。但是不要忘了，其他参数同时也是在改变的呢，只不过是放在了mFlameAnimator里面。

好了介绍到这Flame的介绍完了，任重而道远啊，写了这么多却还没完结，让我想到一某位古人说过，不是我。

还未老死，就先累死

• FireCandle

这名字有点奇怪，火烛，厉害了Word哥。前面已经介绍过ICandle了，现在来看一下他的实现类，蜡烛两兄弟之FireCandle。

初始化照例也就不说了，来看该有的变量。

1. private Paint mPaint;  //中心X坐标 
2.  private int mCenterX;  //记录初始宽 
3.  private int mPreWidth;  //记录初始高 
4.  private int mPreHeight;  //蜡烛芯旋转角 
5.  private int mCandlewickDegrees = 0;  private Flame mFlame;  private boolean mIsFire = false;  private boolean mIsStateOnStart = false;  private boolean mIsStateOnEnd = false;  private boolean mFlagStop = false;  private ValueAnimator mCandlesAnimator; 

命名还是挺规范的，应该一看就知道是干嘛的。

我们还是来主要看绘制和属性动画的配合，绘制就不看了(光速打脸)。来看动画。

1. mCandlesAnimator = ValueAnimator.ofFloat(0, 4).setDuration(4000); 
2.  
3.  mCandlesAnimator.addUpdateListener( 
4.  
5.                   new ValueAnimator.AnimatorUpdateListener() { 
6.  
7.      @Override 
8.  
9.      public void onAnimationUpdate(ValueAnimator animation) { 
10.  
11.          float zeroToOne = (float) animation.getAnimatedValue(); 
12.  
13.          if (zeroToOne <= 1.0f) { 
14.  
15.              //蜡烛芯蓄力下拉 
16.  
17.              mIsFire = true; 
18.  
19.              mCandleWidth = mPreWidth + (int) (zeroToOne * 40); 
20.  
21.              mCandleHeight = mPreHeight - (int) (zeroToOne * 30); 
22.  
23.              mCandlewickDegrees = (int) (-60 + (180 + 60) * zeroToOne); 
24.  
25.              refreshEyePosition(); 
26.  
27.          } else if (zeroToOne <= 2.0f) { 
28.  
29.              zeroToOne = zeroToOne - 1.0f; 
30.  
31.              //蜡烛芯上摆 
32.  
33.              if (zeroToOne <= 0.2f) { 
34.  
35.                  zeroToOne = 1.0f - 5 * zeroToOne; 
36.  
37.                  mIsFire = false; 
38.  
39.                  mCandleWidth = mPreWidth + (int) (zeroToOne * 40); 
40.  
41.                  mCandleHeight = mPreHeight - (int) (zeroToOne * 30); 
42.  
43.                  mCandlewickDegrees = (int) (180 * zeroToOne); 
44.  
45.              } else { 
46.  
47.                  if (mFlameStateListener != null && !mIsStateOnStart) { 
48.  
49.                      mFlameStateListener.flameStart(); 
50.  
51.                      mIsStateOnStart = true; 
52.  
53.                  } 
54.  
55.                  mCandleWidth = mPreWidth; 
56.  
57.                  mCandleHeight = mPreHeight; 
58.  
59.                  mCandlewickDegrees = 0; 
60.  
61.                  if (mFlagStop) { 
62.  
63.                      mCandlesAnimator.cancel(); 
64.  
65.                  } 
66.  
67.              } 
68.  
69.              refreshEyePosition(); 
70.  
71.          } else if (zeroToOne >= 3.5f) { 
72.  
73.              //蜡烛芯被吹歪 
74.  
75.              zeroToOne = 2 * (zeroToOne - 3.5f);//0-1 
76.  
77.              mCandlewickDegrees = (int) (-60 * zeroToOne); 
78.  
79.              if (mFlameStateListener != null && !mIsStateOnEnd) { 
80.  
81.                  mFlameStateListener.flameEnd(); 
82.  
83.                  mIsStateOnEnd = true; 
84.  
85.              } 
86.  
87.          } 
88.  
89.      } 
90.  
91.  });  

这个就过程就有点多了，但是其实一点都不复杂，，首先我们看动画里面的小蜡烛,一开始，他来了一个变胖红脸深蹲，所以呢mCandleWidth是变大的，mCandleHeight是变小的，后面那个灯芯随着深蹲来了一个大角度旋转，灯芯的如何旋转大家也看到了，改变坐标系然后就可以了。用到了

canvas.rotate(mCandlewickDegrees, mCenterX, mCurY - mCandleHeight);这个方法。上摆过程也是一样的，就不多说了。refreshEyePosition();这个方法是改变眼睛位置的，两个地方都用到了所以稍微独立出来了。注意mIsFire这个变量，没有火焰的时候就做其他绘制，比如说红眼睛等等。好了好了，介绍到这，小蜡烛的部分就结束了。

SecCandle

大蜡烛，帅蜡烛镇楼，实际的绘制和小蜡烛的就差不多了，这里就不解释了。

共同绘制View和控制器

AnimControler

这个类的功能很简单，绘制地板部分还有就是把计算后传过来的高度宽度赋给两支蜡烛，然后控制两支蜡烛各自开始动画。

1. mFirCandle = new FirCandle(mRelativeX + mWidth / 6, mRelativeY + mHeight); 
2.  
3.  mFirCandle.initCandle(mFirCandleWidth, mFirCandleHeight); 
4.  
5.  mFirCandle.initAnim(); 
6.  
7.  mSecCandle = new SecCandle(mRelativeX + mWidth / 2, mRelativeY + mHeight); 
8.  
9.  mSecCandle.initCandle(mSecCandleWidth, mSecCandleHeight - 80); 
10.  
11.  mSecCandle.initAnim();  

最后的最后，就是我们的View了

• CandlesAnimView

1. //16ms刷新Canvas 
2.  
3.      mInvalidateAnimator = ValueAnimator.ofInt(0, 1).setDuration(16); 
4.  
5.      mInvalidateAnimator.setRepeatCount(ValueAnimator.INFINITE); 
6.  
7.      mInvalidateAnimator.addListener(new AnimatorListenerAdapter() { 
8.  
9.          @Override 
10.  
11.          public void onAnimationRepeat(Animator animation) { 
12.  
13.              invalidate(); 
14.  
15.          } 
16.  
17.      }); 
18.  
19.      mInvalidateAnimator.start();  

这个属性动画履行的任务就是快速的刷新界面，是Candle的动画能够及时显示。

1. @Override 
2. protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {      super.onMeasure(widthMeasureSpec, heightMeasureSpec);      int width = measureDimension(WIDTH_DEFAULT * mDensity, 
3.                                widthMeasureSpec);      int height = measureDimension(HEIGHT_DEFAULT *mDensity, 
4.                                heightMeasureSpec); 
5.     setMeasuredDimension(width, height); 
6. }  public int measureDimension(int defaultSize, int measureSpec) {      int result;      int specMode = MeasureSpec.getMode(measureSpec);      int specSize = MeasureSpec.getSize(measureSpec);      if (specMode == MeasureSpec.EXACTLY) { 
7.         result = specSize; 
8.     } else { 
9.         result = defaultSize;          if (specMode == MeasureSpec.AT_MOST) { 
10.             result = Math.min(result, specSize); 
11.         } 
12.     }      return result; 
13. }  @Override 
14. protected void onDraw(Canvas canvas) {      if (!mIsInit) { 
15.         initConfig(); 
16.         mIsInit = true; 
17.     } 
18.     mAnimControler.drawMyView(canvas); 
19. } 

可以看到最后在view里面调用了我们的控制器，把cavas传过去了。

最后的tip：大家有没有发现每个动画的duration都是一样的。

三、最后

好了至此，本来一个简单的view自定义被我说了这么多。初次在简书上写，望大家多支持支持。

希望大家有什么建议和意见都可以提出。望斧正。