Android Animation API介绍----简单分析ViewAnimation的执行原理

    <declare-styleable name="Animation">
        <attr name="interpolator" />
        <attr name="fillEnabled" format="boolean" />
        <attr name="fillBefore" format="boolean" />
        <attr name="fillAfter" format="boolean" />
        <attr name="duration" />
        <attr name="startOffset" format="integer" />
        <attr name="repeatCount" format="integer">
            <enum name="infinite" value="-1" />
        </attr>
        <attr name="repeatMode">
            <enum name="restart" value="1" />
            <enum name="reverse" value="2" />
        </attr>
        <attr name="zAdjustment">
            <enum name="normal" value="0" />
            <enum name="top" value="1" />
            <enum name="bottom" value="-1" />
        </attr>
        <attr name="background" />
        <attr name="detachWallpaper" format="boolean" />
        <attr name="showWallpaper" format="boolean" />
        <attr name="hasRoundedCorners" format="boolean" />
    </declare-styleable>

/**
 * Helper for getTransformation. Subclasses should implement this to apply
 * their transforms given an interpolation value.  Implementations of this
 * method should always replace the specified Transformation or document
 * they are doing otherwise.
 *
 * @param interpolatedTime The value of the normalized time (0.0 to 1.0)
 *        after it has been run through the interpolation function.
 * @param t The Transformation object to fill in with the current
 *        transforms.
 */
protected void applyTransformation(float interpolatedTime, Transformation t) {
}

/**
 * Convenience method to start the animation the first time
 * {@link #getTransformation(long, Transformation)} is invoked.
 */
public void start() {
    setStartTime(-1);
}

/**
 * Convenience method to start the animation at the current time in
 * milliseconds.
 */
public void startNow() {
    setStartTime(AnimationUtils.currentAnimationTimeMillis());
}


/**
 * When this animation should start. When the start time is set to
 * {@link #START_ON_FIRST_FRAME}, the animation will start the first time
 * {@link #getTransformation(long, Transformation)} is invoked. The time passed
 * to this method should be obtained by calling
 * {@link AnimationUtils#currentAnimationTimeMillis()} instead of
 * {@link System#currentTimeMillis()}.
 *
 * @param startTimeMillis the start time in milliseconds
 */
public void setStartTime(long startTimeMillis) {
    mStartTime = startTimeMillis;
    mStarted = mEnded = false;
    mCycleFlip = false;
    mRepeated = 0;
    mMore = true;
}

/**
 * Gets the transformation to apply at a specified point in time. Implementations of this
 * method should always replace the specified Transformation or document they are doing
 * otherwise.
 *
 * @param currentTime Where we are in the animation. This is wall clock time.
 * @param outTransformation A transformation object that is provided by the
 *        caller and will be filled in by the animation.
 * @return True if the animation is still running
 */
public boolean getTransformation(long currentTime, Transformation outTransformation) {
    if (mStartTime == -1) {
        mStartTime = currentTime;
    }

    final long startOffset = getStartOffset();//一般情况为0,如果不为0表示动画延迟执行的时间
    final long duration = mDuration;//动画的持续事件
    float normalizedTime;//动画的进度取值在0f-1f之间
    if (duration != 0) {
        normalizedTime = ((float) (currentTime - (mStartTime + startOffset))) /
                (float) duration;//计算动画的进度
    } else {
        // time is a step-change with a zero duration
        normalizedTime = currentTime < mStartTime ? 0.0f : 1.0f;//动画持续时间为0的情况,只要到了过了执行的时间,动画立即执行结束进度为1,这里有可能是负数
    }

    final boolean expired = normalizedTime >= 1.0f || isCanceled();//计算动画是否结束
    mMore = !expired;//没结束的话表示需要更多的动画帧

    if (!mFillEnabled) normalizedTime = Math.max(Math.min(normalizedTime, 1.0f), 0.0f);//mFillEnabled一般为false,仅仅是纠正一下normalizedTime值
//mFillEnabled的值表示计算过程中是否考虑mFillBefore参数的值,ture考虑.默认为false主要考虑mFillAfter的值,,为什么这么说呢?
//看下下面的代码逻辑:mFillEnabled为true的话,normalizedTime为负数的情况下mFillBefore是会被作为参数考虑的.
//对于mFillBefore,mFillAfter我的理解是只有开启mFillEnabled的情况下mFillBefore才会生效,这几个属性仅仅影响的是 是否在动画执行之前或者之后要不要将动画的第一帧或最后一帧动画属性设置给View.
//这直接给我们的体验效果就是动画执行前View就会显示在动画的第一帧的位置,结束的时候并停留在动画结束的位置
    if ((normalizedTime >= 0.0f || mFillBefore) && (normalizedTime <= 1.0f || mFillAfter)) {
        if (!mStarted) {
            fireAnimationStart();//第一帧开始时回调onAnimationStart方法
            mStarted = true;
            if (NoImagePreloadHolder.USE_CLOSEGUARD) {
                guard.open("cancel or detach or getTransformation");
            }
        }

        if (mFillEnabled) normalizedTime = Math.max(Math.min(normalizedTime, 1.0f), 0.0f);

        if (mCycleFlip) {
            normalizedTime = 1.0f - normalizedTime;
        }

        final float interpolatedTime = mInterpolator.getInterpolation(normalizedTime);
        applyTransformation(interpolatedTime, outTransformation);//调用applyTransformation方法计算出当前进度对应的outTransformation信息
    }

    if (expired) {
        if (mRepeatCount == mRepeated || isCanceled()) {
            if (!mEnded) {
                mEnded = true;
                guard.close();
                fireAnimationEnd();
            }
        } else {
            if (mRepeatCount > 0) {
                mRepeated++;
            }

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

            mStartTime = -1;
            mMore = true;

            fireAnimationRepeat();//结束的话回调onAnimationEnd方法,不管是正常结束还是被cancel结束都会回调该方法
        }
    }

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

    return mMore;
}

TextView tv = findViewById(R.id.testtv);
TranslateAnimation translateAnimation = new TranslateAnimation(-100,0,0,1000);
translateAnimation.setDuration(2000);
translateAnimation.setStartOffset(1000);
tv.startAnimation(translateAnimation);

public void startAnimation(Animation animation) {
    animation.setStartTime(Animation.START_ON_FIRST_FRAME);
    setAnimation(animation);//将Animation和View绑定
    invalidateParentCaches();
    invalidate(true);//最终其实就是执行ViewRootImpl的scheduleTraversals,注册vsync信号,等待下次vsync刷新UI
}

boolean draw(Canvas canvas, ViewGroup parent, long drawingTime) {
 .........
    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();
    }
..........
}

private boolean applyLegacyAnimation(ViewGroup parent, long drawingTime,
        Animation a, boolean scalingRequired) {
    Transformation invalidationTransform;
    final int flags = parent.mGroupFlags;
    final boolean initialized = a.isInitialized();
    if (!initialized) {//初始化阶段
        a.initialize(mRight - mLeft, mBottom - mTop, parent.getWidth(), parent.getHeight());
        a.initializeInvalidateRegion(0, 0, mRight - mLeft, mBottom - mTop);
        if (mAttachInfo != null) a.setListenerHandler(mAttachInfo.mHandler);
        onAnimationStart();
    }

    final Transformation t = parent.getChildTransformation();
    boolean more = a.getTransformation(drawingTime, t, 1f);//执行阶段,获取每一帧的Transformation信息
    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) {//如果动画还需要继续执行,继续invalidate,注册vsync信号,重复上述操作
        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 {
            if (parent.mInvalidateRegion == null) {
                parent.mInvalidateRegion = new RectF();
            }
            final RectF region = parent.mInvalidateRegion;
            a.getInvalidateRegion(0, 0, mRight - mLeft, mBottom - mTop, region,
                    invalidationTransform);

            // The child need to draw an animation, potentially offscreen, so
            // make sure we do not cancel invalidate requests
            parent.mPrivateFlags |= PFLAG_DRAW_ANIMATION;

            final int left = mLeft + (int) region.left;
            final int top = mTop + (int) region.top;
            parent.invalidate(left, top, left + (int) (region.width() + .5f),
                    top + (int) (region.height() + .5f));
        }
    }
    return more;
}