关于ValueAnimation以及Interpolator +Drawable实现的自定义动画效果

ValueAnimation :

Android中的属性动画，他跟objectAnimation是比补间动画拥有更强大的功能，可以操作对象，所以我们可以在自
定义View中通过他们来实现些特别的功能。

Interpolator： 

插值器，通过插值器我们能实现比如反弹，重力加速度，等等的效果。

Android本来就自带了插值器，加速减速等等，而且在最新的v4包中还加入了几个新的插值器，可以上网搜下，看看不同的插值器的效果。

Drawable ：Drawable这个类是可以用来绘制的类

通过自定义Drawable 可以实现很多不通过的功能：



因为不是动态图片，看不到实际效果，可以下载Demo自己运行下看看。

关于自定义Drawable 的步骤：

1、用一个类继承Drawable

2、创建一个ValueAnimator 对象，设置他的各种属性以及添加AnimatorUpdateListener，然后通过他的监听器可以设置你控件的动画效果

3、创建一个画笔，用来进行绘制你所要绘制的东西

4、绘制的时候按你的需求来计算要绘制的东西（功能不一样计算方式也不一样）

看上图第一个控件的实现方式：

package com.example.modifyprogress;

import android.animation.ValueAnimator;
import android.animation.ValueAnimator.AnimatorUpdateListener;
import android.annotation.SuppressLint;
import android.graphics.Canvas;
import android.graphics.ColorFilter;
import android.graphics.Path;
import android.graphics.Rect;
import android.graphics.RectF;
import android.graphics.drawable.Drawable;
import android.view.animation.Animation;
import app.dinus.com.loadingdrawable.MaterInterpolator;

@SuppressLint("NewApi")
public class LoadingDrawable extends Drawable{
private Drawable mDrawable;
private Path mPath = new Path();
private float mPercent;
private ValueAnimator mAnimator;
public LoadingDrawable(Drawable drawable) {
this.mDrawable = drawable;

mAnimator = ValueAnimator.ofFloat(0.0f,1.0f);
mAnimator.setDuration(5000);
mAnimator.setRepeatCount(Animation.INFINITE);
mAnimator.setRepeatMode(Animation.REVERSE);
mAnimator.setInterpolator(MaterInterpolator.createInterpolator().setDefault_Type(MaterInterpolator.BOUNCE));
mAnimator.addUpdateListener(new AnimatorUpdateListener() {

@Override
public void onAnimationUpdate(ValueAnimator animation) {

if (mPercent < 1) {
mPercent += (Float)animation.getAnimatedValue()/100;
} else {
mPercent = 0;
}
invalidateSelf();
}
});
mAnimator.start();
}
@Override
public void draw(Canvas canvas) {
mPath.reset();
RectF rect = new RectF(getBounds());
double radius = Math.pow(Math.pow(rect.right, 2) + Math.pow(rect.bottom, 2), 0.5);
mPath.moveTo(rect.right / 2, rect.bottom / 2);
mPath.lineTo(rect.right / 2, 0);
if (mPercent > 0.125f) {
mPath.lineTo(rect.right, 0);
}
if (mPercent > 0.375f) {
mPath.lineTo(rect.right, rect.bottom);
}
if (mPercent > 0.625f) {
mPath.lineTo(0, rect.bottom);
}
if (mPercent > 0.875f) {
mPath.lineTo(0, 0);
}
mPath.lineTo((float) (rect.right / 2 + radius * Math.sin(Math.PI * 2 * mPercent)),
(float) (rect.bottom / 2 - radius * Math.cos(Math.PI * 2 * mPercent)));
mPath.close();
if (mPercent >= 0 && mPercent <= 1) {
canvas.save();
canvas.clipPath(mPath);
mDrawable.draw(canvas);
canvas.restore();
}
}

@Override
public void setAlpha(int alpha) {
mDrawable.setAlpha(alpha);
}

@Override
public int getAlpha() {
return mDrawable.getAlpha();
}

@Override
public void setColorFilter(ColorFilter cf) {
mDrawable.setColorFilter(cf);
}

@Override
public int getOpacity() {
// TODO Auto-generated method stub
return mDrawable.getOpacity();
}

@Override
protected void onBoundsChange(Rect bounds) {
mDrawable.setBounds(bounds);
}

@Override
public int getIntrinsicHeight() {
return mDrawable.getIntrinsicHeight();
}

@Override
public int getIntrinsicWidth() {
return mDrawable.getIntrinsicWidth();
}

public void setPercent(float percent) {
if (percent > 1) {
percent = 1;
} else if (percent < 0) {
percent = 0;
}
if (percent != mPercent) {
this.mPercent = percent;
invalidateSelf();
}
}

}

我自己自定义了几个插值动画，关于插值动画的测试可以在：http://inloop.github.io/interpolator/

package app.dinus.com.loadingdrawable;

import android.view.animation.Interpolator;
/**
*各种插值器效果
* @author chenpengfei_d
*可以去这个网址上看效果： http://inloop.github.io/interpolator/ */
public class MaterInterpolator implements Interpolator{
private int mDefault_Type = LINEAR;
private float interpolatorValue;
private static MaterInterpolator mInterpolator;
public static MaterInterpolator createInterpolator(){
if (mInterpolator == null) {
mInterpolator = new MaterInterpolator();
}
return mInterpolator;
}

@Override
public float getInterpolation(float input) {

switch (mDefault_Type) {
case LINEAR: //线性
interpolatorValue = input;
break;
case ACCELERATE: //加速
float factor = 1.0f;
if (factor == 1.0) {
factor = input * input;
}else {
factor = (float)Math.pow(input, factor *2);
}
interpolatorValue = factor;
break;
case ACCELERATEDECELERATE://先加速后减速
interpolatorValue = (float) ((Math.cos((input + 1) * Math.PI) /2.0) + 0.5F);
break;
case ANTICIPATE:

float tension = 2.0f;
interpolatorValue = input * input *((tension + 1) * input - tension);
break;
case ANTICIPATEOVERSHOOT:
tension = 2.0f * 1.5f;
if (input < 0.5){
interpolatorValue = (float) (0.5 * (Math.pow(input * 2.0f, 2) * ((tension + 1) * input - tension)));
}else {
interpolatorValue = (float) (0.5 *(Math.pow(((input - 1) * 2.0f), 2) *((tension + 1) *(input - 1) * 2.0f + tension)));
}
break;
case BOUNCE://反弹
if (input < 0.3535) {
interpolatorValue = bounce(input);
}else if(input < 0.7408){
interpolatorValue = bounce(input - 0.54719f) + 0.7f;
}else if (input < 0.9644) {
interpolatorValue = bounce(input - 0.8526f) + 0.9f;
}else {
interpolatorValue = bounce(input - 1.0435f) + 0.95f;
}
break;
case CUBICHERMITE:
interpolatorValue = CubicHermite(input, 0, 1, 4, 4);
break;
case CYCLE:
float cycles = 1.0f;
interpolatorValue = (float)Math.sin(2* cycles *Math.PI *input);
break;
case DECELERATE://减速
float divisor = 1.0f;
if (divisor == 1.0) {
interpolatorValue = (float) (1.0 - (1.0 - input ) * (1.0 - input));
}else {
interpolatorValue = (float) (1.0 - Math.pow((1.0 - input), 2 * divisor));
}
break;
case OVERSHOOT:
tension = 2.0f;
input = input - 1.0f;
interpolatorValue = (float) (input *input *((tension + 1) * input + tension ) +1.0);
break;
case SMOOTHSTEP:
interpolatorValue = input * input * (3 - 2 *input );
break;
case SPRING://弹簧效果
factor = 0.4f;
interpolatorValue = (float) (Math.pow(2, -10 *input) * Math.sin((input - factor /4) *(2 *Math.PI)/factor ) + 1.0);
break;
default:
break;
}

return interpolatorValue;
}

private float bounce(float input){
return input *input *8;
}
private float CubicHermite(float t, int p0,int p1,int m0,int m1){
float t2 = t* t;
float t3 = t2 * t ;
return (2* t3 - 3 * t2 +1) * p0 + (t3 - 2 * t2 + t) * m0 + (-2 * t3 + 3 * t2) * p1 + (t3 - t2) *m1;
}
public int getDefault_Type() {
return mDefault_Type;
}
public MaterInterpolator setDefault_Type(int default_Type) {
mDefault_Type = default_Type;
return mInterpolator;
}
public static final int LINEAR =0 ;
public static final int SMOOTHSTEP = 1;
public static final int ACCELERATEDECELERATE = 2;
public static final int BOUNCE = 3;
public static final int ACCELERATE = 4;
public static final int ANTICIPATEOVERSHOOT = 5;
public static final int CYCLE = 6;
public static final int ANTICIPATE = 7;
public static final int DECELERATE = 8;
public static final int OVERSHOOT = 9;
public static final int CUBICHERMITE = 10;
public static final int SPRING = 11;
public enum MaterInterPolatorType{
LINEAR,SMOOTHSTEP,SPRING,CUBICHERMITE,OVERSHOOT,DECELERATE,ANTICIPATE,CYCLE,ANTICIPATEOVERSHOOT
,ACCELERATE,BOUNCE,ACCELERATEDECELERATE
}
}

还有其他的效果可以看代码里边，下载运行就好，效果还不错，个人感觉。

Demo：http://download.csdn.net/detail/u012808234/9498353