void startFrameAnimation() {
    // 执行动画view
    View targetView = findViewById(R.id.tag_desc);
    // 获取动画对象
    AnimationDrawable animationDrawable = (AnimationDrawable) (targetView).getDrawable();
    // 启动动画
    animationDrawable.start();
}

private void setFrame(int frame, boolean unschedule, boolean animate) {
    // 判断当前帧是否在
    if (frame >= mAnimationState.getChildCount()) {
        return;
    }
    // 选取该帧图片
    selectDrawable(frame);
    if (unschedule || animate) {
        unscheduleSelf(this);
    }
    if (animate) {
        // 定时绘制该帧图片
        scheduleSelf(this, SystemClock.uptimeMillis() + mAnimationState.mDurations[frame]);
    }
}

public class AccelerateInterpolator extends BaseInterpolator implements NativeInterpolatorFactory {
    private final float mFactor;
    private final double mDoubleFactor;
 
    public AccelerateInterpolator() {
        mFactor = 1.0f;
        mDoubleFactor = 2.0;
    }
 
       public AccelerateInterpolator(float factor) {
        mFactor = factor;
        mDoubleFactor = 2 * mFactor;
    }
     
    public float getInterpolation(float input) {
        if (mFactor == 1.0f) {
            return input * input;
        } else {
            return (float)Math.pow(input, mDoubleFactor);
        }
    }
 }

/**
 * Start the specified animation now.
 *
 * @param animation the animation to start now
 */
public void startAnimation(Animation animation) {
    animation.setStartTime(Animation.START_ON_FIRST_FRAME);
    setAnimation(animation);
    invalidateParentCaches();
    invalidate(true);
}

boolean draw(Canvas canvas, ViewGroup parent, long drawingTime) {
    final Animation a = getAnimation();
    if (a != null) {
        // 执行动画的核心逻辑
        more = applyLegacyAnimation(parent, drawingTime, a, scalingRequired);
        // 是否需要改变边界martix，除alpha动画外均需要
        concatMatrix = a.willChangeTransformationMatrix();
        if (concatMatrix) {
            mPrivateFlags3 |= PFLAG3_VIEW_IS_ANIMATING_TRANSFORM;
        }
        // 返回值非空
        transformToApply = parent.getChildTransformation();
    } else {
        // ...省略
    }
    // more为false 通知父view动画结束，修改flag值
    if (a != null && !more) {
        if (!hardwareAcceleratedCanvas && !a.getFillAfter()) {
            onSetAlpha(255);
        }
        parent.finishAnimatingView(this, a);
    }
    // more为true 动画状态中
    if (more && hardwareAcceleratedCanvas) {
        // 含有alpha动画需要通知子view更新动画
        if (a.hasAlpha() && (mPrivateFlags & PFLAG_ALPHA_SET) == PFLAG_ALPHA_SET) {
            invalidate(true);
        }
        // 否则子view无需重建canvas
    }
    if (transformToApply）{
        // 进行一些绘制操作
    }
}
}
 
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) {
        //Animation初始化
    }
    // 动画内核心执行逻辑
    boolean more = a.getTransformation(drawingTime, t, 1f);
    ...
    if (more) {//成功
        // 不管是否需要改变边界值，都通知父view更新
        if (!a.willChangeBounds()) {//动画不会改变View的边界，如Alpha动画
           parent.invalidate(mLeft, mTop, mRight, mBottom);
        } else {//动画会改变View的边界，如Scale动画
            parent.invalidate(left, top, left + (int) (region.width() + .5f),
                    top + (int) (region.height() + .5f));
        }
    }
    return more;
}

public boolean getTransformation(long currentTime, Transformation outTransformation) {
    if (duration != 0) { //经历的时间占总耗时的比例
        normalizedTime = ((float) (currentTime - (mStartTime + startOffset))) /(float) duration;
    } else {
        normalizedTime = currentTime < mStartTime ? 0.0f : 1.0f;
    }
    //比例大于等于1说明动画结束
    final boolean expired = normalizedTime >= 1.0f;
    // More标识动画是否结束
    mMore = !expired;
    ...
    // todo mFillBefore如何保证动画结束不改变view布局 没找到具体逻辑，只找到了废弃的逻辑
    if ((normalizedTime >= 0.0f || mFillBefore) && (normalizedTime <= 1.0f || mFillAfter)) {
        // 通过插值器获取当前时间点的相对比值
        final float interpolatedTime = mInterpolator.getInterpolation(normalizedTime);
        // 执行动画核心逻辑，不同animation需重写此方法。
        applyTransformation(interpolatedTime, outTransformation);
    }
    //动画结束
    if (expired) {
        if (mRepeatCount == mRepeated) {
           // 通知动画结束
        } else {
            //判断repeat，reverse等逻辑
        }
    }
    ...
    return mMore;
}

public Object evaluate(float fraction, Object startValue, Object endValue) {
    int startInt = (Integer) startValue;
    float startA = ((startInt >> 24) & 0xff) / 255.0f;
    float startR = ((startInt >> 16) & 0xff) / 255.0f;
    float startG = ((startInt >>  8) & 0xff) / 255.0f;
    float startB = ( startInt        & 0xff) / 255.0f;
 
    int endInt = (Integer) endValue;
    float endA = ((endInt >> 24) & 0xff) / 255.0f;
    float endR = ((endInt >> 16) & 0xff) / 255.0f;
    float endG = ((endInt >>  8) & 0xff) / 255.0f;
    float endB = ( endInt        & 0xff) / 255.0f;
 
    // 默认线性变换，计算中间色值
    float a = startA + fraction * (endA - startA);
    float r = startR + fraction * (endR - startR);
    float g = startG + fraction * (endG - startG);
    float b = startB + fraction * (endB - startB);
 
    return Math.round(a) << 24 | Math.round(r) << 16 | Math.round(g) << 8 | Math.round(b);
}

public Float evaluate(float fraction, Number startValue, Number endValue) {
    float startFloat = startValue.floatValue();
    // 返回对应的float中间值
    return startFloat + fraction * (endValue.floatValue() - startFloat);
}

private void start(boolean playBackwards) {
    if (Looper.myLooper() == null) {
        throw new AndroidRuntimeException("Animators may only be run on Looper threads");
    }
    mReversing = playBackwards;
    mSelfPulse = !mSuppressSelfPulseRequested;
    // 如果需要反向执行动画，反向修改当前进度值
    if (playBackwards && mSeekFraction != -1 && mSeekFraction != 0) {
        // ..
    }
    // 修改标记值
    mStarted = true;
    mPaused = false;
    mRunning = false;
    mAnimationEndRequested = false;
    // Resets mLastFrameTime when start() is called, so that if the animation was running,
    // calling start() would put the animation in the
    // started-but-not-yet-reached-the-first-frame phase.
    mLastFrameTime = -1;
    mFirstFrameTime = -1;
    mStartTime = -1;
 
 
    // 关键方法
    addAnimationCallback(0);
 
    if (mStartDelay == 0 || mSeekFraction >= 0 || mReversing) {
        // 若无需延迟，直接执行动画，这里做了些初始化和通知回调的逻辑
        startAnimation();
        // 更新fraction
        setCurrentFraction(mSeekFraction);
    }
}

private void addAnimationCallback(long delay) {
    if (!mSelfPulse) {
        return;
    }
    // AnimationHandler是一个单例
    getAnimationHandler().addAnimationFrameCallback(this, delay);
}
 
private final Choreographer.FrameCallback mFrameCallback = new Choreographer.FrameCallback() {
    @Override
    public void doFrame(long frameTimeNanos) {
        // 执行本帧动画
        doAnimationFrame(getProvider().getFrameTime());
        // 持续执行下一帧动画
        if (mAnimationCallbacks.size() > 0) {
            getProvider().postFrameCallback(this);
        }
    }
};
/**
 * Register to get a callback on the next frame after the delay.
 */
public void addAnimationFrameCallback(final AnimationFrameCallback callback, long delay) {
    // 若第一次执行动画，或之前动画已执行完
    if (mAnimationCallbacks.size() == 0) {
        getProvider().postFrameCallback(mFrameCallback);
    }
    if (!mAnimationCallbacks.contains(callback)) {
        mAnimationCallbacks.add(callback);
    }
    if (delay > 0) {
        mDelayedCallbackStartTime.put(callback, (SystemClock.uptimeMillis() + delay));
    }
}

private void doAnimationFrame(long frameTime) {
    long currentTime = SystemClock.uptimeMillis();
    final int size = mAnimationCallbacks.size();
    // 遍历动画队列（mAnimationCallbacks）
    for (int i = 0; i < size; i++) {
        final AnimationFrameCallback callback = mAnimationCallbacks.get(i);
        if (callback == null) {
            continue;
        }
        // 判断当前时间是否到达（需要延迟返回false)
        if (isCallbackDue(callback, currentTime)) {
            // 这里调用了animator的doAnimationFrame方法
            callback.doAnimationFrame(frameTime);
            if (mCommitCallbacks.contains(callback)) {
                getProvider().postCommitCallback(new Runnable() {
                    @Override
                    public void run() {
                        commitAnimationFrame(callback, getProvider().getFrameTime());
                    }
                });
            }
        }
    }
    // 清理动画队列mAnimationCallbacks
    cleanUpList();
}
 
 
/**
 * Processes a frame of the animation, adjusting the start time if needed.
 *
 * @param frameTime The frame time.
 * @return true if the animation has ended.
 * @hide
 */
public final boolean doAnimationFrame(long frameTime) {
    // 处理 pause/resume
    if (mPaused) {
        // ...
        return false
    } else if (mResumed) {
        // ...
    }
    // 允许动画已被触发过
    if (mLastFrameTime < 0) {
        if (mSeekFraction >= 0) {
            long seekTime = (long) (getScaledDuration() * mSeekFraction);
            mStartTime = frameTime - seekTime;
            mSeekFraction = -1;
        }
        mStartTimeCommitted = false; // allow start time to be compensated for jank
    }
    // 重要代码
    boolean finished = animateBasedOnTime(currentTime);
    // 若动画结束，进行一些清理工作
    if (finished) {
        endAnimation();
    }
    return finished;
}
boolean animateBasedOnTime(long currentTime) {
    // 是否完成动画
    boolean done = false;
    if (mRunning) {
        // 是否全部循环执行完
        final boolean lastIterationFinished = (fraction >= mRepeatCount + 1) &&
                (mRepeatCount != INFINITE);
        // 判断是否已结束
        if (scaledDuration == 0) {
            // 0 duration animator, ignore the repeat count and skip to the end
            done = true;
        } else if (newIteration && !lastIterationFinished) {
            // Time to repeat
            // ...
        } else if (lastIterationFinished) {
            done = true;
        }
        // 获取当前进度值
        float currentIterationFraction = getCurrentIterationFraction(
                mOverallFraction, mReversing);
        // 关键方法
        animateValue(currentIterationFraction);
    }
    return done;
}
 
 
void animateValue(float fraction) {
    // 根据插值器重新获取进度值
    fraction = mInterpolator.getInterpolation(fraction);
    mCurrentFraction = fraction;
    // 通过PropertyValuesHolder计算当前进度下的值
    int numValues = mValues.length;
    for (int i = 0; i < numValues; ++i) {
        mValues[i].calculateValue(fraction);
    }
    // 通知update回调，返回最新进度
    if (mUpdateListeners != null) {
        int numListeners = mUpdateListeners.size();
        for (int i = 0; i < numListeners; ++i) {
            mUpdateListeners.get(i).onAnimationUpdate(this);
        }
    }
}

public static ObjectAnimator ofInt(Object target, String propertyName, int... values) {
    ObjectAnimator anim = new ObjectAnimator(target, propertyName);
    anim.setIntValues(values);
    return anim;
}
 
 
private ObjectAnimator(Object target, String propertyName) {
    setTarget(target);
    setPropertyName(propertyName);
}

void animateValue(float fraction) {
    final Object target = getTarget();
    // 获取目标对象，对不符合预期的情况进行取消
    if (mTarget != null && target == null) {
        // We lost the target reference, cancel and clean up. Note: we allow null target if the
        /// target has never been set.
        cancel();
        return;
    }
 
    super.animateValue(fraction);
    int numValues = mValues.length;
    // 自动修改对象值
    for (int i = 0; i < numValues; ++i) {
        mValues[i].setAnimatedValue(target);
    }
}

//传统写法
ObjectAnimator tX = ObjectAnimator.ofFloat(textView, "translationX", currentX, -300, currentX);
ObjectAnimator tY = ObjectAnimator.ofFloat(textView, "translationY", currentY, 200, currentY);
AnimatorSet set = new AnimatorSet();
set.setDuration(1000).playTogether(tX, tY);
set.start();
  
//一个view同时发生多种效果时，建议使用PropertyValuesHolder，这样ObjectAnimator只有一个对象
PropertyValuesHolder pvhX = PropertyValuesHolder.ofFloat("translationX", currentX, 500, currentX);
PropertyValuesHolder pvhY = PropertyValuesHolder.ofFloat("translationY", currentY, 400, currentY);
ObjectAnimator.ofPropertyValuesHolder(textView, pvhX, pvhY).setDuration(1000).start();

//传统写法
ObjectAnimator transYFirstAnim = ObjectAnimator.ofFloat(textView, "translationY", 0, 100);
ObjectAnimator transYSecondAnim = ObjectAnimator.ofFloat(textView, "translationY", 100, 0);
AnimatorSet animSet = new AnimatorSet();
animSet.playSequentially(transYFirstAnim, transYSecondAnim);
  
 //一个view的单个属性先后发生一系列变化时，建议使用Keyframe达到效果。从词义上来理解Keyframe是关键帧
Keyframe k0 = Keyframe.ofFloat(0f, 0); //第一个参数为“何时”，第二个参数为“何地”
Keyframe k1 = Keyframe.ofFloat(0.5f, 100);
Keyframe k2 = Keyframe.ofFloat(1f, 0);
PropertyValuesHolder p = PropertyValuesHolder.ofKeyframe("translationY", k0, k1, k2);
ObjectAnimator objectAnimator = ObjectAnimator.ofPropertyValuesHolder(textView, p);
objectAnimator.start();