个人觉得，一款移动应用软件，影响用户体验的很大一部分就取决于动画，Android中也是如此，因此在应用层开发中我个人也很注重动画的使用，在能够熟练使用后就想探究其原理了，因此，开这篇博客不仅仅是对动画的一个总结，也是对动画的更深入的一个探究。话不多说，开写了。
Android动画可以分为三类：Tween Animation（补间动画）、Frame Animatino（帧动画）、Property Animation（属性动画），其中，补间动画比较简单，无非就是平移、缩放、透明度渐变，这些只需要根据相关api设置好想要的结果参数即可，想要达到预期效果可能会经过不断地调试设置~0.0~，当然，如果是老手，已经熟练了，熟练到知道一个dp、sp在手机上是多少个单位以及结果图在脑海里的样子 -0-会很容易了~。本文会重点介绍补间动画和属性动画，尤其是属性动画。
一、补间动画
1. 补间动画的使用
补间动画又分为四大类，分别是：旋转动画、平移动画、缩放动画、透明度渐变动画。下面从xml开始依次介绍动画的用法和相关的属性，最后通过直接用代码实现动画来探究其原理。
（1）旋转动画RoateAnimation
在补间动画中，动画都是平面2D效果，因此旋转动画也是指逆时针或顺时针旋转，其用法无非就是设置各个属性，其各属性含义如下：
<?xml version="1.0" encoding="utf-8"?>
<!-- 旋转动画 -->
<!--
====== 属性说明 =========
formDegrees: 开始旋转前的角度
toDegrees: 旋转后的角度
pivotX: 中心点X的坐标，其单位%p表示相对父容器的坐标，%表示相对自己的坐标，没有单位只有数字则是指在屏幕上坐标的x轴坐标
pivotY: 旋转中心店Y的坐标
duration: 动画持续时间
fillAfter: 如果为true（前提是fillEnable不是false，fillEnable属性默认为true），则动画执行完毕后会保留执行后的状态
startOffset: 动画开始的延迟时间，单位是毫秒，比如如果该值为3000，那么动画就在3秒后执行
repeatCount： 动画执行的次数
repeatMode： 重复的方式，枚举类型，有两种选择"restart"表示执行完一次动画后又从头执行，"reverse"本身就是相反的意思，
它表示动画执行完动画后沿着原来旋转的方向反向旋转回来
-->
<rotate xmlns:android="http://schemas.android.com/apk/res/android"
android:detachWallpaper="true"
android:duration="1400"
android:fillAfter="false"
android:fromDegrees="0"
android:pivotX="50%"
android:pivotY="50%"
android:repeatCount="2"
android:repeatMode="reverse"
android:toDegrees="180"
android:zAdjustment="bottom" >
</rotate>值得注意的就是pivotX和pivotY属性的单位，如果带有%表示相对自己旋转，如假设pivotX和pivotY都是50%，则表示动画以本视图的中心点（宽/2和高/2）旋转，如果是50%p，则表示动画以该视图的父视图的中心点来旋转。如果是50，则表示相对于屏幕坐标系的绝对坐标来旋转。
xml设置动画完毕，就差在java代码中使用了，使用方法很简单，如下两行代码搞定：
Animation anima = AnimationUtils.loadAnimation(mContext, R.anim.anim_rote);
mImageView.startAnimation(anima);
/**
* 旋转
* @param view
*/
public void onRote(View view){
// Animation anima = AnimationUtils.loadAnimation(mContext, R.anim.anim_rote);
mFlag++;
Animation anima = null;
if(mFlag%2==1){
mToDegrees =180;
mFromeDegrees = 0;
anima = new RotateAnimation(mFromeDegrees, mToDegrees,Animation.RELATIVE_TO_SELF, 0.5F, Animation.RELATIVE_TO_SELF,0.5F);
}else if(mFlag%2==0){
mToDegrees =360;
mFromeDegrees = 180;
anima = new RotateAnimation(mFromeDegrees, mToDegrees, Animation.RELATIVE_TO_SELF, 0.5F, Animation.RELATIVE_TO_SELF,0.5F);
}
anima.setDuration(1000);
anima.setFillAfter(true);
anima.setRepeatMode(Animation.REVERSE);
anima.setRepeatCount(2);
anima.setAnimationListener(new AnimationListener());
mImageView.startAnimation(anima);
}
/**
* 动画监听
*
* @author Administrator
*
*/
@SuppressLint("NewApi")
private class AnimationListener implements
android.view.animation.Animation.AnimationListener {
@Override
public void onAnimationEnd(Animation animation) {
// TODO Auto-generated method stub
Animation anima = AnimationUtils.loadAnimation(mContext,
R.anim.anim_rote_01);
// mImageView.startAnimation(anima);
// mImageView.postInvalidate();
// startActivity(new---activity);
Toast.makeText(mContext, "动画执行结束", Toast.LENGTH_LONG).show();
}
@Override
public void onAnimationRepeat(Animation animation) {
// TODO Auto-generated method stub
Toast.makeText(mContext, "动画重复", Toast.LENGTH_LONG).show();
}
@Override
public void onAnimationStart(Animation animation) {
// TODO Auto-generated method stub
Toast.makeText(mContext, "动画开始了", Toast.LENGTH_LONG).show();
}
}
/**
* Constructor used when a RotateAnimation is loaded from a resource.
*
* @param context Application context to use
* @param attrs Attribute set from which to read values
*/
public RotateAnimation(Context context, AttributeSet attrs) {
//此构造器是在用AnimationUtils.load的时候被调用，我们并不会直接使用到，官方注释已经很清楚了。
}
/**
* Constructor to use when building a RotateAnimation from code.
* Default pivotX/pivotY point is (0,0).
* 这个构造器比较简单，就是一个起始角度和结束角度，一般比较少用，因为我们需要指定旋转中心点
* @param fromDegrees Rotation offset to apply at the start of the
* animation.
*
* @param toDegrees Rotation offset to apply at the end of the animation.
*/
public RotateAnimation(float fromDegrees, float toDegrees) {
mFromDegrees = fromDegrees;
mToDegrees = toDegrees;
mPivotX = 0.0f;
mPivotY = 0.0f;
}
/**
* Constructor to use when building a RotateAnimation from code
* 这个用的也不是很多，就是在上一个构造器的基础上添加了poivotX和pivotY两个参数用于指定旋转点
* @param fromDegrees Rotation offset to apply at the start of the
* animation.
*
* @param toDegrees Rotation offset to apply at the end of the animation.
*
* @param pivotX The X coordinate of the point about which the object is
* being rotated, specified as an absolute number where 0 is the left
* edge.
* @param pivotY The Y coordinate of the point about which the object is
* being rotated, specified as an absolute number where 0 is the top
* edge.
*/
public RotateAnimation(float fromDegrees, float toDegrees, float pivotX, float pivotY) {
mFromDegrees = fromDegrees;
mToDegrees = toDegrees;
mPivotXType = ABSOLUTE;
mPivotYType = ABSOLUTE;
mPivotXValue = pivotX;
mPivotYValue = pivotY;
initializePivotPoint();
}
/**
* Constructor to use when building a RotateAnimation from code
* 重点就是这个构造器，是我们常用的，第三个参数是用于指定旋转的类型，有三种选择：
* 1、相对自己(通过Animation.RELATIVE_TO_SELF设置) 2、绝对旋转（相对屏幕坐标系，通过Animation.ABSOLUTE）
* 3、相对父视图。我们通过Animation.RELATIVE_TO_PARENT设置
*
* @param fromDegrees Rotation offset to apply at the start of the
* animation.
*
* @param toDegrees Rotation offset to apply at the end of the animation.
*
* @param pivotXType Specifies how pivotXValue should be interpreted. One of
* Animation.ABSOLUTE, Animation.RELATIVE_TO_SELF, or
* Animation.RELATIVE_TO_PARENT.
* @param pivotXValue The X coordinate of the point about which the object
* is being rotated, specified as an absolute number where 0 is the
* left edge. This value can either be an absolute number if
* pivotXType is ABSOLUTE, or a percentage (where 1.0 is 100%)
* otherwise.
* @param pivotYType Specifies how pivotYValue should be interpreted. One of
* Animation.ABSOLUTE, Animation.RELATIVE_TO_SELF, or
* Animation.RELATIVE_TO_PARENT.
* @param pivotYValue The Y coordinate of the point about which the object
* is being rotated, specified as an absolute number where 0 is the
* top edge. This value can either be an absolute number if
* pivotYType is ABSOLUTE, or a percentage (where 1.0 is 100%)
* otherwise.
*/
public RotateAnimation(float fromDegrees, float toDegrees, int pivotXType, float pivotXValue,
int pivotYType, float pivotYValue) {
mFromDegrees = fromDegrees;
mToDegrees = toDegrees;
mPivotXValue = pivotXValue;
mPivotXType = pivotXType;
mPivotYValue = pivotYValue;
mPivotYType = pivotYType;
initializePivotPoint();
}
（2）平移动画TranslateAnimation（略）
（3）缩放动画ScaleAnimation（略）
（4）透明度渐变动画AlphaAnimation（略）
上面就以旋转动画为例，将动画的通用属性展示出来，至于平移、缩放、透明度都是一样一样的，就几个特性不一样，但是都可以见名思意的，因此在这里不再赘述。下面直接进入主题，补间动画的实现原理分析，源码分析依然是从RoateAnimation开始。
2.补间动画原理源码初窥
（1）xml文件加载过程分析
通常我们加载xml文件生成一个Animation对象时，是用过Google封装的AnimationUtils的loadAnimation（）方法，那么我们就从这个方法看看一个xml文件是如何让一个View动起来的。
/**
* Loads an {@link Animation} object from a resource
*
* @param context Application context used to access resources
* @param id The resource id of the animation to load
* @return The animation object reference by the specified id
* @throws NotFoundException when the animation cannot be loaded
*/
public static Animation loadAnimation(Context context, int id)
throws NotFoundException {
//XmlResourceParser接口是继承XmlPullParser解析器和AttributeSet接口的，AttributeSet接口以前说过，就不用再说了，
//
XmlResourceParser parser = null;
try {
//这里根据id获取解析器然后调用createAnimationFormXml方法生成一个Animation对象
parser = context.getResources().getAnimation(id);
return createAnimationFromXml(context, parser);
} catch (XmlPullParserException ex) {
NotFoundException rnf = new NotFoundException("Can't load animation resource ID #0x" +
Integer.toHexString(id));
rnf.initCause(ex);
throw rnf;
} catch (IOException ex) {
NotFoundException rnf = new NotFoundException("Can't load animation resource ID #0x" +
Integer.toHexString(id));
rnf.initCause(ex);
throw rnf;
} finally {
if (parser != null) parser.close();
}
}
private static Animation createAnimationFromXml(Context c, XmlPullParser parser,
AnimationSet parent, AttributeSet attrs) throws XmlPullParserException, IOException {
//声明一个Animationd对象
Animation anim = null;
// Make sure we are on a start tag.
int type;
int depth = parser.getDepth();
//再说一次，Android中对资源xml文件解析都是使用Pull解析的，这里先判断是否有下一个节点，是否结束
while (((type=parser.next()) != XmlPullParser.END_TAG || parser.getDepth() > depth)
&& type != XmlPullParser.END_DOCUMENT) {
if (type != XmlPullParser.START_TAG) {
continue;
}
String name = parser.getName();
//如果是set节点（就是我们多中组合动画的SetAnimation了），就递归调用自己，直到把所有的动画解析完毕
//然后下面是一系列的判断根据alpha、scale、rotate、translate来生成不同的动画
if (name.equals("set")) {
anim = new AnimationSet(c, attrs);
createAnimationFromXml(c, parser, (AnimationSet)anim, attrs);
} else if (name.equals("alpha")) {
anim = new AlphaAnimation(c, attrs);
} else if (name.equals("scale")) {
anim = new ScaleAnimation(c, attrs);
} else if (name.equals("rotate")) {
anim = new RotateAnimation(c, attrs);
} else if (name.equals("translate")) {
anim = new TranslateAnimation(c, attrs);
} else {
throw new RuntimeException("Unknown animation name: " + parser.getName());
}
if (parent != null) {
parent.addAnimation(anim);
}
}
return anim;
} 首先看下这个类中定义的属性字段，不多，所以全贴出来：
private float mFromDegrees;
private float mToDegrees;
//注意这里，看到，默认的mPivotXType是绝对的，就是相对于坐标系的，这个ABSLUTE是在RoateAnimation的父类Animation中
//定义的
private int mPivotXType = ABSOLUTE;
private int mPivotYType = ABSOLUTE;
private float mPivotXValue = 0.0f;
private float mPivotYValue = 0.0f;
private float mPivotX;
private float mPivotY;public RotateAnimation(Context context, AttributeSet attrs) {
super(context, attrs);
//获取类型数组，就是xml中属性值得类型，int、float等
TypedArray a = context.obtainStyledAttributes(attrs,
com.android.internal.R.styleable.RotateAnimation);
//获取到旋转后的位置角度以及开始的角度
mFromDegrees = a.getFloat(
com.android.internal.R.styleable.RotateAnimation_fromDegrees, 0.0f);
mToDegrees = a.getFloat(com.android.internal.R.styleable.RotateAnimation_toDegrees, 0.0f);
//这个不用看，就封装了旋转类型和旋转角度的一系列转换
Description d = Description.parseValue(a.peekValue(
com.android.internal.R.styleable.RotateAnimation_pivotX));
mPivotXType = d.type;
mPivotXValue = d.value;
d = Description.parseValue(a.peekValue(
com.android.internal.R.styleable.RotateAnimation_pivotY));
mPivotYType = d.type;
mPivotYValue = d.value;
a.recycle();
//这个方法只有当mPivotXType为ABSOLUTE时才会起作用
initializePivotPoint();
} @Override
public void initialize(int width, int height, int parentWidth, int parentHeight) {
super.initialize(width, height, parentWidth, parentHeight);
mPivotX = resolveSize(mPivotXType, mPivotXValue, width, parentWidth);
mPivotY = resolveSize(mPivotYType, mPivotYValue, height, parentHeight);
}
/**
* Start the specified animation now.
*
* @param animation the animation to start now
*/
public void startAnimation(Animation animation) {
animation.setStartTime(Animation.START_ON_FIRST_FRAME);
//给该View设置一个动画
setAnimation(animation);
//使父容器缓存失效
invalidateParentCaches();
//意思就是使这个View失效，那么它就需要进行重绘，上面设置了一个setAnimation（），那么重绘时就会执行相应的动画了
//关于动画的一切都从这里开始，下一篇博客会从这个方法开始讲起
invalidate(true);
}
@Override
protected void applyTransformation(float interpolatedTime, Transformation t) {
float degrees = mFromDegrees + ((mToDegrees - mFromDegrees) * interpolatedTime);
float scale = getScaleFactor();
if (mPivotX == 0.0f && mPivotY == 0.0f) {
t.getMatrix().setRotate(degrees);
} else {
//如果有旋转点就设置旋转的中心点，先获取一个Matrix（矩阵）
t.getMatrix().setRotate(degrees, mPivotX * scale, mPivotY * scale);
}
}/**
* Defines the transformation to be applied at
* one point in time of an Animation.
*意思就是：定义一个动画执行时的某个时间点的变换，这个变换是一个名词哈！稍后深入原理我们会讲到这个类。
*/
/**
* Set the matrix to rotate about (0,0) by the specified number of degrees.
* 这里调用了native_setRotate()方法，这个方法并不是java实现的，而是C，这个方法声明在Matrix如：
* private static native void native_setRotate(int native_object,float degrees, float px, float py);
*/
public void setRotate(float degrees) {
native_setRotate(native_instance, degrees);
}
二、属性动画（Property Animation）
属性动画是3.0后才有的特性，它比比补间动画要灵活且实现的功能更多一些，首先看·下关于属性动画的几个类：
（1）ValueAnimator： 动画执行类
（2）ObjectAnimator：动画执行类，是ValueAnimator的子类
（3）AnimatorSet：复杂组合动画，可以同时完成多个属性动画
（4） AnimatorInflater：用于加载xml的属性文件动画，和AnimationUtils.loadAnimation()作用一样
（5） TypeEvaluator ： 类型估值，主要用于设置动画操作属性的值
（6）TimeInterpolator：时间插值，也就是插值器
1、ObjectAnimator的用法
（1）从xml加载属性动画
xml的旋转属性动画文件如下：
<?xml version="1.0" encoding="utf-8"?>
<objectAnimator xmlns:android="http://schemas.android.com/apk/res/android"
android:duration="3000"
android:propertyName="rotationX"
android:repeatCount="120"
android:valueFrom="0.0"
android:valueTo="360.0"
android:valueType="floatType" />ObjectAnimator objAnima = (ObjectAnimator) AnimatorInflater.loadAnimator(this, R.animator.property_anima);
objAnima.setTarget(mImageView);
objAnima.start();
<?xml version="1.0" encoding="utf-8"?>
<set xmlns:android="http://schemas.android.com/apk/res/android"
>
<!-- 绕X轴旋转 -->
<objectAnimator
android:duration="30000"
android:propertyName="rotationX"
android:repeatCount="120"
android:valueFrom="0.0"
android:valueTo="360.0"
android:valueType="floatType" />
<!-- 绕Y轴旋转 -->
<objectAnimator
android:duration="30000"
android:propertyName="rotationY"
android:repeatCount="120"
android:valueFrom="0.0"
android:valueTo="360.0"
android:valueType="floatType" />
</set>（2）在代码中直接创建ObjectAnimator动画
代码如下，实现和上面的一样绕着X轴旋转的效果
ObjectAnimator objAnima = ObjectAnimator.ofFloat(mImageView, "rotationX", 0.0F,360F);
objAnima.setDuration(3000);
objAnima.start();
ObjectAnimator objAnima = ObjectAnimator.ofFloat(mImageView, "rotationX", 0.0F,360F);
objAnima.setDuration(3000);
ObjectAnimator objAnima1 = ObjectAnimator.ofFloat(mImageView, "rotationY", 0.0F,360F);
objAnima1.setDuration(3000);
ObjectAnimator objAnima2 = ObjectAnimator.ofFloat(mImageView, "alpha",1.0F,0.2F);
objAnima2.setDuration(3000);
AnimatorSet animaSet = new AnimatorSet();
//设置objAnima和objAnima1、objAnima2同时执行
animaSet.play(objAnima).with(objAnima1);
animaSet.play(objAnima1).with(objAnima2);
animaSet.start();2、ValueAnimator用法
ValueaNnimator并不需要指定属性名称，而是通过监听来手动设置属性的，使用如下：
ValueAnimator valueAnima = ValueAnimator.ofFloat(0.0F,360F);
valueAnima.addUpdateListener(new AnimatorUpdateListener() {
@Override
public void onAnimationUpdate(ValueAnimator va) {
float value = (Float) va.getAnimatedValue();
mImageView.setRotationX(value);
mImageView.setRotationY(value);
}
});
valueAnima.setDuration(3000);
valueAnima.start();现在我们知道了属性动画的基本用法，用法很是灵活，可以根据需求来实现很多丰富的效果，在Animator中还有两个重要的方法，那就是setEvaluator()和setInterpolator(null);关于这两个方法我们在动画下一篇博客里会说到。
三、动画的高级用法
1、补间动画的差之器Interpolator
插值器是一个时间插值类，实际上是一个速率的控制类，就是控制了动画在执行的过程中速率的控制，Interpolator是一个空的接口，源码如下：
/**
* An interpolator defines the rate of change of an animation. This allows
* the basic animation effects (alpha, scale, translate, rotate) to be
* accelerated, decelerated, repeated, etc.
*/
public interface Interpolator extends TimeInterpolator {
// A new interface, TimeInterpolator, was introduced for the new android.animation
// package. This older Interpolator interface extends TimeInterpolator so that users of
// the new Animator-based animations can use either the old Interpolator implementations or
// new classes that implement TimeInterpolator directly.
}
- AccelerateDecelerateInterpolator============动画开始与结束的地方速率改变比较慢，在中间的时候加速。
- AccelerateInterpolator===================动画开始的地方速率改变比较慢，然后开始加速。
- AnticipateInterpolator ==================开始的时候向后然后向前甩。
- AnticipateOvershootInterpolator=============开始的时候向后然后向前甩一定值后返回最后的值。
- BounceInterpolator=====================动画结束的时候弹起。
- CycleInterpolator======================动画循环播放特定的次数，速率改变沿着正弦曲线。
- DecelerateInterpolator===================在动画开始的地方快然后慢。
- LinearInterpolator======================以常量速率改变。
- OvershootInterpolator====================向前甩一定值后再回到原来位置。
- PathInterpolator========================新增的，就是可以定义路径坐标，然后可以按照路径坐标来跑动；注意其坐标并不是 XY，而是单方向，也就是我可以从0~1，然后弹回0.5 然后又弹到0.7 有到0.3，直到最后时间
/**
* An interpolator where the rate of change is constant
*
*/
public class LinearInterpolator implements Interpolator {
public LinearInterpolator() {
}
public LinearInterpolator(Context context, AttributeSet attrs) {
}
//这个参数就是输入的
public float getInterpolation(float input) {
return input;
}
}
/**
* Repeats the animation for a specified number of cycles. The
* rate of change follows a sinusoidal pattern.
*
*/
public class CycleInterpolator implements Interpolator {
public CycleInterpolator(float cycles) {
mCycles = cycles;
}
public CycleInterpolator(Context context, AttributeSet attrs) {
TypedArray a =
context.obtainStyledAttributes(attrs, com.android.internal.R.styleable.CycleInterpolator);
mCycles = a.getFloat(com.android.internal.R.styleable.CycleInterpolator_cycles, 1.0f);
a.recycle();
}
//这个值input就是一个小数，在0~1之间，0表示动画的开始，1表示动画结束，
public float getInterpolation(float input) {
return (float)(Math.sin(2 * mCycles * Math.PI * input));
}
private float mCycles;
}
/**
* 自定义差之器
* @author Administrator
*
*/
private class MyInterpolator implements Interpolator{
@Override
public float getInterpolation(float input) {
//这是我随便写的一个“算法”....
float range = (float) (Math.cos(input)*Math.PI);
return range;
}
} 本文完结。
扫一扫
3516
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
