android动画之interpolator和typeEvaluator用法详解手机开发

Interpolator （插值器）

我们在写动画的时候为了达到某种效果往往需要设置插值器，用来真实的模拟生活中的场景。

 Interpolator （插值器）被用来修饰动画效果，定义动画的变化率，可以使存在的动画效果accelerated(加速)，decelerated(减速),repeated(重复),bounced(弹跳)等。

结构图：

常见的插值器：

 AccelerateDecelerateInterpolator 在动画开始与结束的地方速率改变比较慢，在中间的时候加速

  AccelerateInterpolator  在动画开始的地方速率改变比较慢，然后开始加速

  AnticipateInterpolator 开始的时候向后然后向前甩

  AnticipateOvershootInterpolator 开始的时候向后然后向前甩一定值后返回最后的值

  BounceInterpolator  动画结束的时候弹起

  CycleInterpolator 动画循环播放特定的次数，速率改变沿着正弦曲线

  DecelerateInterpolator 在动画开始的地方快然后慢

  LinearInterpolator  以常量速率改变

  OvershootInterpolator  向前甩一定值后再回到原来位置

如果上面的插值器不满足你的要求，你可以自定义插值器。

我们看一个效果

这里我自定义了一个插值器，实现匀速的转动

public class MyInterpolator extends LinearInterpolator { 

 private float factor; 

 public MyInterpolator() { 

 this.factor = 0.15f; 

 @Override 

 public float getInterpolation(float input) { 

 return (float) (Math.pow(2, -10 * input) 

 * Math.sin((input - factor / 4) * (2 * Math.PI) / factor) + 1); 

}

接下来我们要说说Android属性动画的估值器。

TypeEvaluator（估值器）

TypeEvaluator（估值器）：ValueAnimator.ofObject()函数来做动画效果的时候就会用到，作用是估算我们动画执行到什么程度，什么时间执行什么动画的一个类。估值器用到了TypeEvaluator这个接口：

public interface TypeEvaluator t { 

 /** 

 * @param fraction The fraction from the starting to the ending values 

 * @param startValue The start value. 

 * @param endValue The end value. 

 * @return A linear interpolation between the start and end values, given the 

 * code fraction /code parameter. 

 public T evaluate(float fraction, T startValue, T endValue); 

}

这里有三个函数：
fraction: 表示当前这段数值变化值得比例，startValue：表示当前这段数值变化的开始值，endValue: 表示当前这段数据变化的结束值。

估值器在哪里用得到呢，很多地方，举一个简单的例子，如用属性动画执行帧动画效果。

那么估值器是怎么工作的呢，我们来看下ValueAnimator的源码，其中在KeyframeSet类里有这么一个方法，这就是估值器工作的地方

public Object getValue(float fraction) { 

 // Special-case optimization for the common case of only two keyframes 

 if (mNumKeyframes == 2) { 

 if (mInterpolator != null) { 

 fraction = mInterpolator.getInterpolation(fraction); 

 return mEvaluator.evaluate(fraction, mFirstKeyframe.getValue(), 

 mLastKeyframe.getValue()); 

 if (fraction = 0f) { 

 final Keyframe nextKeyframe = mKeyframes.get(1); 

 final TimeInterpolator interpolator = nextKeyframe.getInterpolator(); 

 if (interpolator != null) { 

 fraction = interpolator.getInterpolation(fraction); 

 final float prevFraction = mFirstKeyframe.getFraction(); 

 float intervalFraction = (fraction - prevFraction) / 

 (nextKeyframe.getFraction() - prevFraction); 

 return mEvaluator.evaluate(intervalFraction, mFirstKeyframe.getValue(), 

 nextKeyframe.getValue()); 

 } else if (fraction = 1f) { 

 final Keyframe prevKeyframe = mKeyframes.get(mNumKeyframes - 2); 

 final TimeInterpolator interpolator = mLastKeyframe.getInterpolator(); 

 if (interpolator != null) { 

 fraction = interpolator.getInterpolation(fraction); 

 final float prevFraction = prevKeyframe.getFraction(); 

 float intervalFraction = (fraction - prevFraction) / 

 (mLastKeyframe.getFraction() - prevFraction); 

 return mEvaluator.evaluate(intervalFraction, prevKeyframe.getValue(), 

 mLastKeyframe.getValue()); 

 Keyframe prevKeyframe = mFirstKeyframe; 

 for (int i = 1; i mNumKeyframes; ++i) { 

 Keyframe nextKeyframe = mKeyframes.get(i); 

 if (fraction nextKeyframe.getFraction()) { 

 final TimeInterpolator interpolator = nextKeyframe.getInterpolator(); 

 final float prevFraction = prevKeyframe.getFraction(); 

 float intervalFraction = (fraction - prevFraction) / 

 (nextKeyframe.getFraction() - prevFraction); 

 // Apply interpolator on the proportional duration. 

 if (interpolator != null) { 

 intervalFraction = interpolator.getInterpolation(intervalFraction); 

 return mEvaluator.evaluate(intervalFraction, prevKeyframe.getValue(), 

 nextKeyframe.getValue()); 

 prevKeyframe = nextKeyframe; 

 // shouldnt reach here 

 return mLastKeyframe.getValue(); 

 }

在这之前有一个方法：

 void calculateValue(float fraction) { 

 Object value = mKeyframes.getValue(fraction); 

 mAnimatedValue = mConverter == null ? value : mConverter.convert(value); 

 }

调用到了getValue()，得到的值放在了mAnimatedValue里面，要通过PropertyValuesHolder类的getAnimatedValue()函数来得这个值

而这个函数在ValusAnimator中有调用。

void animateValue(float fraction) { 

 fraction = mInterpolator.getInterpolation(fraction); 

 mCurrentFraction = fraction; 

 int numValues = mValues.length; 

 for (int i = 0; i numValues; ++i) { 

 mValues[i].calculateValue(fraction); 

 if (mUpdateListeners != null) { 

 int numListeners = mUpdateListeners.size(); 

 for (int i = 0; i numListeners; ++i) { 

 mUpdateListeners.get(i).onAnimationUpdate(this); 

 }

Android系统内置了很多的估值器：

如下几种估值器 ArgbEvaluator, FloatArrayEvaluator, FloatEvaluator, IntArrayEvaluator, IntEvaluator, PointFEvaluator, RectEvaluator。

当然我们也可以自定义估值器，比我我们自定义一个实现字符从A_Z变化的估值器。

public class CalEvaluator implements TypeEvaluator character { 

 @Override 

 public Character evaluate(float fraction, Character startValue, Character endValue) { 

 int startInt = (int) startValue; 

 int endInt = (int) endValue; 

 int cur = (int) (startInt + fraction * (endInt - startInt)); 

 return (char) cur; 

}

 

代码链接：点击打开链接

5667.html

app程序应用开发手机开发无线开发移动端开发