动画详解之视图动画

1.动画的定义

动画就是在两个不同的场景之间，添加过渡，让过程看起来尽可能自然（也可以说和现实世界的物理规律相符合),常见的场景有

• 表现层级关系： 为了展现层与层的关系，是抽屉，是打开，还是平级切换等等，让用户知道这个界面和上一个、下一个的关系。这已经是非常最常见的运用了，如QQ侧滑打开个人中心

• 与用户手势/遥控器 结合，更自然的动画表现 ： 当用户手势操作的时候，让界面的动态走向更符合手指的运动，从而让用户感觉到是自己控制了界面的动向，而不是机械化的跳转，通常会配合震动、视图的选中状态来表现

• 减少不可避免的不适感： 启动，下载，加载，刷新，发送 等界面，适当的动画效果让等待变的可视化，用户就没有那么无聊，产品体验也会上升；

• 不易被察觉的动效 1.比如B站的点赞特效， 2.随着用户的操作，有的内容已经是用户不再关注的。这时候可以将他们隐藏起来,比如说标题栏。

2.动画的分类和基本使用

视图按照大类分为两类：ViewAnimation(视图动画）和 PropertyAnimator(属性动画);视图动画又包含Tween Animation(补间动画)和Frame Animation(帧动画)，属性动画包含ValueAnimator 和 objectAnimator。

下面一个个来介绍一下他们的基本使用 先上效果图

2.1 补间动画--Alpha(透明度）

2.1.1. 使用xml 实现Alpha动画：

达到View的透明度从某个值变化到某个值的效果，现在res文件夹下，新建一个文件夹anim,存放xml文件，以后的关于动画的xml文件都放在这个文件夹下，xml文件夹下

<?xml version="1.0" encoding="utf-8"?>
<alpha xmlns:android="http://schemas.android.com/apk/res/android"
    android:fromAlpha="1.0"
    android:toAlpha="0.1"
    android:duration = "2000"
    android:fillAfter="false"
    android:fillBefore="true"
    >
</alpha>

然后再activity中可以这样使用

binding.btAlpha.setOnClickListener {
    //加载动画
    val animation = AnimationUtils.loadAnimation(this@AnimatorActivity,R.anim.alpha_anim)
    //调用startAnimation 开始动画
    //动画开始之后，会将imageview的透明度从1.0变为0.1，并保持不变
    binding.ivCat.startAnimation(animation)
}

• android：fromAlpha 取值为0.0 - 1.0 ，0.0表示全透明，1表示不透明

• android：toAlpha 取值为0.0 - 1.0，0.0表示全透明，1表示不透明

• android：duration 表示持续时间，持续4s

• android：fillBefore:设置为true,动画结束之后，复原到初始状态，默认值为true

• android：fillAfter 设置为true,动画结束之后，保持动画结束时的状态,默认值为false

• android：fillEnabled 与fillBefore效果相同，

• 当fillBefore 和 fillAfter 同时设置为true 时，fillAfter的优先级高于fillBefore，动画将维持在最后一帧 透明度效果图如下：

2.1.2. 使用纯代码的形式

AlphaAnimation的构造函数为

1.AlphaAnimation(context:Context!,attrs:AttributeSet!) //用于从xml中构建Animation对象
2.AlphaAnimation(fromAlpha:Float,toAlpha:Float,) //代码构建对象

因此可以像下面这样写

val animation  = AlphaAnimation(1.0f,0.2f)
animation.duration = 2000   // 设置动画持续时间
animation.fillAfter = true  //动画结束之后维持在最后一帧
binding.ivCat.startAnimation(animation) //开始动画

透明度效果图如下：

2.2 补间动画--Scale(缩放）

2.2.1.使用xml实现scale动画，

scale标签用于缩放view,从而实现调整控件尺寸的效果

<?xml version="1.0" encoding="utf-8"?>
<scale xmlns:android="http://schemas.android.com/apk/res/android"
    android:fromXScale="1.0"
    android:toXScale="1.4"
    android:fromYScale="1.0"
    android:toYScale="1.4"
    android:duration = "1000"
    android:fillAfter = "true">
</scale>

• android:fromXscale 动画开始时，view在X轴上相对于自身的缩放比例，1.0 等于view 自身的大小，0.5为view 自身的0.5倍，2.0为view 自身的2 倍

• android:toXscale 动画结束时，view在X 轴上相对于自身的缩放比例

• android:fromYScale 动画开始时，view 在Y轴上相对于自身的缩放比例

• android:toYScale 动画结束时，view在Y轴上相对于自身的缩放比例

• 在scale 标签中，pivotX 和pivotY 指定动画的开始坐标，有3种不同的取值，20，20%，20%p，20表示动画从距离左上角20单位的距离开始，20%表示动画从距离左边 （view的宽度*0.2）的位置开始，20%p 表示从距离view的最左上角边（父容器的宽度或者高度 乘以 0.2)的开始，view 在

• 在rotate 标签种，pivotX 和 pivotY 指定动画旋转中心的坐标

  上面整个xml 表示这个view 在动画开始时，从自身的1.0倍变化到自身的1.4倍，持续时间为1s,并在动画结束之后维持在最后一帧。 调用过程为

 binding.btScale.setOnClickListener {
       val animation = AnimationUtils.loadAnimation(this@AnimatorActivity,R.anim.scale_anim)
       binding.ivCat.startAnimation(animation)
 }

2.2.2.使用纯代码的形式实现scale动画

//ScaleAnimation对象 的构建方法有4个，
//第一个是我们从xml中加载animation时会用到的构造函数，
//第2，3，4是我们自己使用代码构建ScaleAnimation对象时会使用的构造方法。
1.ScaleAnimation(context:Context!,attrs:AttributeSet!) //用于从xml中构建Animation对象
2.ScaleAnimation(fromx:Float,toX:Float,fromY:Float,toY:Float)//动画默认从左上角开始
3.ScaleAnimation(fromX:Float,toX:Float,fromY:Float,toY:Float,pivotX:Float,pivotY:Float)//动画从开发者指定的位置开始
4.ScaleAnimation(fromX:Float,toX:Float,fromY:Float,toY:Float,pivotXType:Int,povitXValue:Float,
              povitYType:Int,povitYValue:Float)//动画从开发者指定的位置开始

在xml中 标签中的pivotx 中有3种取值模式，分别是数值，百分数，百分数p,体现在构建函数中就是用pivotXTYPE和pivotYTYPE 区分它们的类型，取值可以是下面这3种

Animation.ABSOLUTE,Animation_RELATEIVE_TO_SELF和 Animation_RELATIVE_TO_PARENT

<scale xmlns:android="http://schemas.android.com/apk/res/android"
    android:fromXScale="1.0"
    android:toXScale="1.4"
    android:fromYScale="1.0"
    android:toYScale="1.4"
    android:povitX = "40%p"
    android:povitY = "40%p"
    android:duration = "1000"
    android:fillAfter = "true">
</scale>

上面标签用代码表示可以表示为

val scaleAnimation = ScaleAnimation(1.0f,1.4f,1.0f,1.4f,40%,RELETIVE_TO_PARENT,
                                   40%,RELETIVE_TO_PARENT)
scaleAnimation.apply{
    duration = 1000
    fillAfter = true
}
binding.ivCat.startAnimation(scaleAnimation) //开始动画

2.3 补间动画--translate(移动)

Translate 主要用于控件位置的移动，可以实现类似于上滑解锁，滑块等动画

2.3.1 使用xml定义translate动画

<translate xmlns:android="http://schemas.android.com/apk/res/android"
           android:fromXDelta ="0"
           android:toXDelta = "-180"
           android:fromYDelta = "0"
           android:toYDelta = "100"
           android:duration = "2000"
           android:fillAfter = "true"
           />

• fromXDelta 控件开始移动时左上角的位置的X轴坐标
• fromYDelta 控件开始移动时左上角的位置的Y轴坐标
• toXDelata 控件结束移动式左上角的位置的X轴坐标，负值代表向反方向移动，即向左移动，正值即向右边移动
• toYDelata 控件结束移动式左上角的位置的Y轴坐标，负值代表向反方向移动，即向上移动，正值即向下边移动

2.3.2 使用代码实现translate动画

TranslationAnimation对象的构造方法有3个，分别是

Translation(context:Context!,attrs:AttributeSet!) //用于从xml中加载动画
Translation(fromXDelta:Float,toXDelta:Float,fromYDelta:Float,toYDelta:Float)
Translation(fromXType:Int,fromXValue:Float,toXType:Int,toXValue:Float,fromYType:Int,fromYValue:Float             toYType:Int,toYValue:Float)

fromXType,toXType,fromYType,toYType的取值同样是3个，分别是 - RELATIVE_TO_SELF - RELATIVE_TO_PARENT - RELATIVE_TO_ABSOULTE

实现和上面xml一样效果可以这样写

val tranalationAnimation = TranslationAnimation(0f,-180f,0f,200f).apply{
    duration = 2000
    fillAfter =  true
}
binding.ivCat.startAnimation(animation)

2.4 补间动画--rotate(旋转动画)

2.4.1 使用xml实现如下

<?xml version="1.0" encoding="utf-8"?>
<rotate xmlns:android="http://schemas.android.com/apk/res/android"
    android:fromDegrees="0"
    android:toDegrees="650"
    android:pivotX="0" 
    android:pivotY="0"
    android:duration = "4000"
    android:fillAfter = "true"
    />

使用

binding.btRotate.setOnClickListener {
            val animation = AnimationUtils.loadAnimation(this@AnimatorActivity,R.anim.rotate_anim)
            binding.ivCat.startAnimation(animation)
        }

• android:fromDegrees 旋转的开始角度

• android:toDegrees 旋转的结束角度，正数为顺时针方向，负数为逆时针方向

• pivotX 旋转动画的中心的横坐标，可以为整数，百分数，百分数+p，20，30%，30%p类似于上面的解释

• pivotY 旋转动画的中心的纵坐标

• android:interpolator 用于设定插值器，其实就是指定动画效果，比如先慢后快，弹跳效果

2.4.2 实现代码实现旋转动画

构造函数如下：

TranslateAnimation(context:Context!,attrs:AttributeSet) //从xml中加载动画
TranslateAnimation(fromDegrees:Float,toDegrees:Float)
TranslateAnimation(fromDegress:Float,toDegrees:Float,pivotX:Float,pivotY:Float)
TranslateAnimation(fromDegress:Float,toDegrees:Float,pivotXType:Int,pivotXValue:Float,pivotType:Int,pivotYValue:Float)

pivotXType和pivotYType的value的和上面TranslationAnimation的值相同

实现类似2.4.1的效果可以使用代码如下

val rotateAnimation = RotateAnimation(0f,-650f,Animation_TO_ABSOLUTE,0,Animation_TO_ABSOLUTE,0).apply{
    duration = 4000
    fillAfter = true
}

2.5 动画集合

前面的动画只能完整特定的动画效果，而set标签可以将这些标签都包含在一个容器里面，一起生效，下面是一个例子

2.5.1 xml实现如下

<?xml version="1.0" encoding="utf-8"?>
<set xmlns:android="http://schemas.android.com/apk/res/android"
    android:fillAfter="true"
    android:repeatMode="reverse"
    android:duration="2000"
    >
    <alpha
        android:fromAlpha="0.0"
        android:toAlpha="1.0"
        android:repeatCount = "4"/>
    <scale
        android:fromXScale="0.5"
        android:toXScale="1.4"
        android:fromYScale="0.5"
        android:toYScale="1.4"
        android:pivotY="50%"
        android:pivotX="50%"
        android:repeatCount = "4"/>
    <rotate
        android:fromDegrees="0"
        android:toDegrees="710"
        android:pivotX="50%"
        android:pivotY="50%"
        android:repeatCount = "4"
        />
</set>

上面的set 标签实现了透明度从0到1.0，长度和宽度从0.5拉伸到1.4倍，并旋转710，重复4次，单次持续时间为2s,重复模式为reverse

2.5.2 纯代码实现如下

val animationSet = AnimationSet(true)
              val alphaAnimation = AlphaAnimation(0f,1f).apply { repeatCount = 4 }
              val scaleAnimation = ScaleAnimation(0.5f,1.4f,0.5f,1.4f,
                  Animation.RELATIVE_TO_SELF,0.5f,Animation.RELATIVE_TO_SELF,0.5f).apply { repeatCount = 4 }
              val rotateAnimation = RotateAnimation(0f,710f,0.5f,0.5f).apply { repeatCount = 4 }
              animationSet.apply {
                    addAnimation(alphaAnimation)
                    addAnimation(scaleAnimation)
                    addAnimation(rotateAnimation)
                    duration = 2000
                    fillAfter = true
                    repeatMode = Animation.REVERSE  //重复时，从最终状态向开始状态变化

              }
             binding.ivCat.startAnimation(animationSet)

2.6 视图动画的其他方法

AlphaAnimation、ScaleAnimation、TranslateAnimation、RotateAnimation、AnimationSet都是Animation类的抽象类，Animation里面定义了一些公共方法 - void cancel() 取消动画 ，例如 animationSet.cancel(),scaleAnimation.cancel()

• void reset() 将view 重置到动画开始的状态

• void setAnimationListener(Animation.AnimationListener listener) 设置动画监听，可以在某个时刻进行事件的处理

animationSet.setAnimationListener(object :Animation.AnimationListener {
                 override fun onAnimationStart(animation: Animation?) {
                     TODO("Not yet implemented")
                     //动画开始时
                 }

                 override fun onAnimationEnd(animation: Animation?) {
                     TODO("Not yet implemented")
                      //动画结束时
                 }

                 override fun onAnimationRepeat(animation: Animation?) {
                     //动画重复时
                 }

             })

2.7 视图动画的优缺点总结：

• 优点： 可以实现基本的缩放，旋转，平移，透明度变换，以及这四种变换的组 合动画
• 缺点： 不能实现复杂动画效果。 可以实现组合动画（AnimationSet），但是组合动画只能同时播，不能控制动画播放的先后顺序 不能监听动画的执行过程，只能监听到动画开始，结束和重复事件。

2.8 视图动画的原理解析

2.8.1 动画开始的入口

 val translateAnimation = TranslateAnimation(0f,180f,0f,200f)
            translateAnimation.duration = 2000
            translateAnimation.fillAfter = true
    //动画开始  
          binding.ivCat.startAnimation(translateAnimation)

跟踪下去

// View.java中
 public void startAnimation(Animation animation) {
        animation.setStartTime(Animation.START_ON_FIRST_FRAME);
       //设置关联动画
        setAnimation(animation);
      //用于指示此视图的父级应清除其缓存。此功能用于强制父级重建其显示列表（当硬件加速时），这在视图的各种父级管理属性发生更改时是必要的，例如 alpha、translationXY、scrollXY、scaleXY 和 rotationXY。此方法仅清除父缓存，不会导致无效事件
        invalidateParentCaches();
      //触发视图重绘
        invalidate(true);
    }

最后跟踪到view.java中

void invalidate(boolean invalidateCache) {
        invalidateInternal(0, 0, mRight - mLeft, mBottom - mTop, invalidateCache, true);
    }
    void invalidateInternal(int l, int t, int r, int b, boolean invalidateCache,
            boolean fullInvalidate) {
        if (mGhostView != null) {
            mGhostView.invalidate(true);
            return;
        }

        if (skipInvalidate()) {
            return;
        }

        if ((mPrivateFlags & (PFLAG_DRAWN | PFLAG_HAS_BOUNDS)) == (PFLAG_DRAWN | PFLAG_HAS_BOUNDS)
                || (invalidateCache && (mPrivateFlags & PFLAG_DRAWING_CACHE_VALID) == PFLAG_DRAWING_CACHE_VALID)
                || (mPrivateFlags & PFLAG_INVALIDATED) != PFLAG_INVALIDATED
                || (fullInvalidate && isOpaque() != mLastIsOpaque)) {
            //部分代码省略
            // Propagate the damage rectangle to the parent view.
            final AttachInfo ai = mAttachInfo;
            final ViewParent p = mParent;
            if (p != null && ai != null && l < r && t < b) {
                final Rect damage = ai.mTmpInvalRect;
                damage.set(l, t, r, b);
                //执行ViewParent的invalidateChild方法
                p.invalidateChild(this, damage);
            }
            //部分代码省略
        }
    }
}

注意到p的类型是ViewParent,是一个抽象类，我们找到它的子类ViewGroup ViewGroup中

public abstract class ViewGroup extends View implements ViewParent, ViewManager {
    /***部分代码省略***/
    public final void invalidateChild(View child, final Rect dirty) {
        ViewParent parent = this;
        final AttachInfo attachInfo = mAttachInfo;
        if (attachInfo != null) {
            /***部分代码省略***/
            do {
                /***部分代码省略***/
                //向顶部的View便利找到根View，即：ViewRootImpl
                //执行ViewRootImpl的invalidateChildInParent方法
                parent = parent.invalidateChildInParent(location, dirty);
                if (view != null) {
                    // Account for transform on current parent
                    Matrix m = view.getMatrix();
                    if (!m.isIdentity()) {
                        RectF boundingRect = attachInfo.mTmpTransformRect;
                        boundingRect.set(dirty);
                        m.mapRect(boundingRect);
                        dirty.set((int) (boundingRect.left - 0.5f),
                                (int) (boundingRect.top - 0.5f),
                                (int) (boundingRect.right + 0.5f),
                                (int) (boundingRect.bottom + 0.5f));
                    }
                }
                /***部分代码省略***/
            } while (parent != null);
        }
    }
}

这里调用了函数invalidateChildInParent()，需要注意的是这里这个函数的实现有两个，一个是ViewGroup中，而另一个是ViewRootImpl。 ViewRootImpl中：

public final class ViewRootImpl implements ViewParent,
        View.AttachInfo.Callbacks, HardwareRenderer.HardwareDrawCallbacks {  
    /***部分代码省略***/

    @Override
    public ViewParent invalidateChildInParent(int[] location, Rect dirty) {
        checkThread();
        /***部分代码省略***/
        invalidateRectOnScreen(dirty);
        return null;
    }

    private void invalidateRectOnScreen(Rect dirty) {
        /***部分代码省略***/
        if (!mWillDrawSoon && (intersected || mIsAnimating)) {
            //开始View的绘制任务
            scheduleTraversals();
        }
    }
}

函数scheduleTraversals()的逻辑其实是执行一个Runnable，而这个Runnable其实就是去执行函数doTraversal(),而函数doTraversal()会调用performTraversals(),到这里我们发现它开始重绘了。总体来说就是动画的执行会导致整个View Tree重绘，但是Android内部有一些优化，比如一张图片做移动，我们不需要真正的去重新绘制，Android内部提供缓存机制，不会显示的再调用onDraw(canvas)函数

public class View implements Drawable.Callback, KeyEvent.Callback,
        AccessibilityEventSource {    
    //部分代码省略
    public void draw(Canvas canvas) {
        /***部分代码省略***/
        //如果有子 View(DecorView当然有子View)，就会调用dispatchDraw() 将绘制事件通知给子 View。
        //ViewGroup 重写了 dispatchDraw()，调用了 drawChild()
        //drawChild() 调用了子 View 的 draw(Canvas, ViewGroup, long)
    }
    boolean draw(Canvas canvas, ViewGroup parent, long drawingTime) {
        final boolean hardwareAcceleratedCanvas = canvas.isHardwareAccelerated();
        /***部分代码省略***/
        Transformation transformToApply = null;
        boolean concatMatrix = false;
        final boolean scalingRequired = mAttachInfo != null && mAttachInfo.mScalingRequired;
        final Animation a = getAnimation();
        if (a != null) {
            more = applyLegacyAnimation(parent, drawingTime, a, scalingRequired);
            concatMatrix = a.willChangeTransformationMatrix();
            if (concatMatrix) {
                mPrivateFlags3 |= PFLAG3_VIEW_IS_ANIMATING_TRANSFORM;
            }
            transformToApply = parent.getChildTransformation();
        } else {
            /***部分代码省略***/
        }
        /***部分代码省略***/
        // 动画数据应用在RenderNode或者Canvas上的!!!!
        if (transformToApply != null) {
            if (concatMatrix) {
                if (drawingWithRenderNode) {
                    // 应用动画数据
                    renderNode.setAnimationMatrix(transformToApply.getMatrix());
                } else {
                    canvas.translate(-transX, -transY);
                    // 应用动画数据
                    canvas.concat(transformToApply.getMatrix());
                    canvas.translate(transX, transY);
                }
                parent.mGroupFlags |= ViewGroup.FLAG_CLEAR_TRANSFORMATION;
            }
    
            float transformAlpha = transformToApply.getAlpha();
            if (transformAlpha < 1) {
                // 应用动画数据
                alpha *= transformAlpha;
                parent.mGroupFlags |= ViewGroup.FLAG_CLEAR_TRANSFORMATION;
            }
        }
    }

    private boolean applyLegacyAnimation(ViewGroup parent, long drawingTime,
            Animation a, boolean scalingRequired) {
        /***部分代码省略***/
        //绘制动画的当前帧，并获取当前动画的状态（是否继续运行）
        boolean more = a.getTransformation(drawingTime, t, 1f);
        if (scalingRequired && mAttachInfo.mApplicationScale != 1f) {
            if (parent.mInvalidationTransformation == null) {
                parent.mInvalidationTransformation = new Transformation();
            }
            invalidationTransform = parent.mInvalidationTransformation;
            a.getTransformation(drawingTime, invalidationTransform, 1f);
        } else {
            invalidationTransform = t;
        }
        //如果动画没有结果
        if (more) {
            if (!a.willChangeBounds()) {
                if ((flags & (ViewGroup.FLAG_OPTIMIZE_INVALIDATE | ViewGroup.FLAG_ANIMATION_DONE)) ==
                        ViewGroup.FLAG_OPTIMIZE_INVALIDATE) {
                    parent.mGroupFlags |= ViewGroup.FLAG_INVALIDATE_REQUIRED;
                } else if ((flags & ViewGroup.FLAG_INVALIDATE_REQUIRED) == 0) {
                    // The child need to draw an animation, potentially offscreen, so
                    // make sure we do not cancel invalidate requests
                    parent.mPrivateFlags |= PFLAG_DRAW_ANIMATION;
                    //进行绘制
                    parent.invalidate(mLeft, mTop, mRight, mBottom);
                }
            } else {
                /***部分代码省略***/
                //进行绘制
                parent.invalidate(left, top, left + (int) (region.width() + .5f),
                        top + (int) (region.height() + .5f));
            }
        }
        return more;
    }
}

View.draw(Canvas) —> ViewGroup.dispatchDraw(Canvas) —> ViewGroup.drawChild(Canvas, View, long) —> View.draw(Canvas, ViewGroup, long) —> View.applyLegacyAnimation(ViewGroup, long, Animation, boolean)

2.2.3 计算动画进度，进行矩阵变换

public abstract class Animation implements Cloneable { 
    /***部分代码省略***/
    public boolean getTransformation(long currentTime, Transformation outTransformation) {
        /***部分代码省略***/
        //执行时间是否过期
        final boolean expired = normalizedTime >= 1.0f;
        mMore = !expired;
        //动画进度为0.0~1.0之间
        if (!mFillEnabled) normalizedTime = Math.max(Math.min(normalizedTime, 1.0f), 0.0f);

        if ((normalizedTime >= 0.0f || mFillBefore) && (normalizedTime <= 1.0f || mFillAfter)) {
            /***部分代码省略***/
            //插值器计算动画执行进度
            final float interpolatedTime = mInterpolator.getInterpolation(normalizedTime);
            //真正的动画效果代码执行处(通过矩阵变化)
            applyTransformation(interpolatedTime, outTransformation);
        }
        //如果动画绘制完成
        if (expired) {
            //判断动画是否需要继续循环
            if (mRepeatCount == mRepeated) {
                if (!mEnded) {
                    mEnded = true;
                    guard.close();
                    fireAnimationEnd();
                }
            } else {
                if (mRepeatCount > 0) {
                    mRepeated++;
                }

                if (mRepeatMode == REVERSE) {
                    mCycleFlip = !mCycleFlip;
                }

                mStartTime = -1;
                mMore = true;

                fireAnimationRepeat();
            }
        }
        if (!mMore && mOneMoreTime) {
            mOneMoreTime = false;
            return true;
        }
        return mMore;
    }
}

以RotateAnimation动画为例，分析它的applyTransformation方法

 @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 {
            t.getMatrix().setRotate(degrees, mPivotX * scale, mPivotY * scale);
        }
    }

说明：Animation的运行依赖Android本身的机制回调（每帧都得回调getTransformation和applyTransformation）无法自身进行运算计算fraction，并且可参与运算的只有Transformation对象里的alpha和matrix，所以Animation只能实现简单的Alpha，Scale，Translate，Rotate变换效果。

3 逐帧动画

逐帧动画是指一帧一帧的播放动画，每一帧由一个图片组成，

3.1xml 定义和使用

<?xml version = "1.0" encoding = "utf-8"?>
<animation-list xmlns:android = "http//schemas.android.como/apk/res/android"
android:oneshot= "true" || "false"
>
   <item 
	android:drawable="@drawable/drawable_name_1
	android:duration = "1000"
  <item 
	android:drawable="@drawable/drawable_name_2
	android:duration = "1000"
>
</animation-list>

• 根元素为animation-list,是必须的，可以包含一个或者以上的item, android:oneshot = "true"动画只会执行一次，false则会一直循环
• item 中 drawable指向资源文件的名字，duration 指的是持续时间，第一个item的持续时间完了，就播放第二个item,以此类推

然后通过ImageView 设置动画资源，通常有两种方法设置imageView的背景，一是android:src ；而是android:background 在imageview中设置第一帧的图片

<ImageView
  android:layout_width = "match_parent"
  android:layout_height = "match_parent"
   android:background = "@drawable/drawable_name_1"
/>

或者是

<ImageView
  android:layout_width = "match_parent"
  android:layout_height = "match_parent"
   android:src = "@drawable/drawable_name_1"
/>

接着在代码处调用

val imageView = findViewById<ImageView>(R.id.frame_image)
val animation = image.background
//或者是（src 对应drawable ；background 对应backround)
val animation = image.drawable
animation.start() //开始动画

3.2 使用代码实现

使用代码时，我们要用到的是AnimationDrawable类，常用方法有 - void start() //开始播放逐帧动画 - void stop() //停止播放 - int getDuration(int index) //获取第index帧的持续时间 - Drawable getFrame(int index) //获取指定index帧对应的drawable对象 - int getNumberOfFrames() 获取帧数 - boolean isRunning() 动画是否在播放 - void setOneShot(boolean oneShot) true为播放一次，false循环播放 - boolean isOneShot() 判断动画的播放类型，是播放一次还是循环播放的 - void addFrame(Drawable frame,int duration) 为动画添加一帧，表明持续时间

代码实现如下

val imageview = findViewById<ImageView>(R.id.frame_image)
val anim = AnimationDrawable()
for(i in 1..4){
val id = resources.getIdentifier("drawable_name_$i","drawable",packageName)
val drawable = resouces.getDrawable(id)
anim.addFrame(drawable,1000)
}
anim.isOneShot = false
imageview.setBackgroundDrawable(anim)
anim.start()

ps:objectValue和ValueObject的后面另起一篇文章太长了