转载请注明原文链接：http://www.jianshu.com/p/b0e7c92ecb43

1.前言

最近在看项目代码中，突然冒出这样一个想法：如果在ObjectAnimator动画结束回调函数onAnimationEnd中重新start此动画，是否能达到循环播放动画呢？其实通过setRepeatCount()和setRepeatMode()函数配合使用也是可以实现动画循环播放的效果，但是出于好奇，我还是想通过代码实现来验证自己的想法，代码如下：

final ObjectAnimator objectAnimator = ObjectAnimator.ofFloat(target, "scaleX", 1.0f, 2.0f)
        .setDuration(5000);
objectAnimator.addListener(new Animator.AnimatorListener() {
    @Override
    public void onAnimationStart(Animator animation) {
        Log.d("MainActivity", "onAnimationStart");
    }

    @Override
    public void onAnimationEnd(Animator animator) {
        Log.d("MainActivity", "onAnimationEnd");
        objectAnimator.start();
    }

    @Override
    public void onAnimationCancel(Animator animation) {
        Log.d("MainActivity", "onAnimationCancel");
    }

    @Override
    public void onAnimationRepeat(Animator animation) {
        Log.d("MainActivity", "onAnimationRepeat");
    }
});
objectAnimator.start();

通过代码实验，惊奇地发现，动画并没有达到我预期的效果，这个渐显动画只是播放了两次而已，且在第二次动画过程中没有onAnimationStart和onAnimationEnd方法的回调。

这是为什么呢？由此激起了我对ObjectAnimator源码实现的兴趣。在这边博客中，主要分析ObjectAnimator动画实现机制以及ObjectAnimator在Duration时间内是如何更新Target属性值，希望对感兴趣的同学有一些帮助。

2.基本使用

ObjectAnimator
        .ofFloat(button, "alpha", 0.0f, 1.0f)
        .setDuration(5000)
        .start();

3.深入分析

3.1 从ObjectAnimator.ofFloat()开始

public static ObjectAnimator ofFloat(Object target, String propertyName, float... values) {
    ObjectAnimator anim = new ObjectAnimator(target, propertyName);
    anim.setFloatValues(values);
    return anim;
}

这个静态方法会创建一个ObjectAnimator对象，在构造时同时设置属性动画的目标target和作用于target的属性名propertyName，根据上面的例子，target为button，propertyName为alpha。

3.1.1 ObjectAnimator构造函数

private ObjectAnimator(Object target, String propertyName) {
    setTarget(target);
    setPropertyName(propertyName);
}

在ObjectAnimator构造函数中分别调用了setTarget和setPropertyName方法

3.1.2 下面我们来分析ObjectAnimator.setTarget()方法

@Override
public void setTarget(@Nullable Object target) {
    final Object oldTarget = getTarget();
    if (oldTarget != target) {
        if (isStarted()) {
            cancel();
        }
        mTarget = target == null ? null : new WeakReference<Object>(target);
        // New target should cause re-initialization prior to starting
        // 记录尚未初始化,ValueAnimator的初始化标志位
        mInitialized = false; 
    }
}

从源码中，我们可以分析出两点：

• 当oldTarget不等于target，且已经调用了start()方法使得mStarted标志位为true时，需要先cancel掉此动画，进入ValueAnimator.cancel()函数，你会发现，系统会先遍历mLiseners调用AnimatorLisener.onAnimatorCancel()函数，接着调用ObjectAnimator.endAnimation函数，最后遍历mLiseners调用AnimatorLisener.onAnimatorEnd()函数。这里矫正了我之前的一个误区，不知道你之前是否也这样的误区，在调用ObjectAnimtor.cancel()动画时，不仅仅会回调AnimatorLisener.onAnimatorCancel()方法,还会回调AnimatorLisener.onAnimatorEnd()方法;

• mTarget是一个软引用，而不是一个强引用哦，这样ObjectAnimator就不会持有View的引用，不会影响Activity的正常回收，从而不会引起Activity内存泄漏。

3.1.3 接着分析ObjectAnimator.setPropertyName()方法

回到ObjectAnimator构造函数中，setPropertyName方法设置属性名称，即为alpha

// 设置属性名称，也就是上面设置的”alpha"
public void setPropertyName(@NonNull String propertyName) {
    // mValues could be null if this is being constructed piecemeal. Just record the
    // propertyName to be used later when setValues() is called if so.
    // mValues是一个数组，用于保存PropertyValuesHolder
    if (mValues != null) {
        // 属性值得更新操作委托给PropertyValuesHolder进行
        // Animator只进行数值计算
        PropertyValuesHolder valuesHolder = mValues[0];
        String oldName = valuesHolder.getPropertyName();
        // 更新第一个PropertyValuesHolder的PropertyName
        valuesHolder.setPropertyName(propertyName);
        mValuesMap.remove(oldName);
        mValuesMap.put(propertyName, valuesHolder);
    }
    mPropertyName = propertyName;
    // New property/values/target should cause re-initialization prior to starting
    // 记录尚未初始化,ValueAnimator的标志位
    mInitialized = false;
}

回到ObjectAnimator.OfFloat()方法中，还有一步就是调用ObjectAnimator.setFloatValues()方法

3.1.4 ObjectAnimator.setFloatValues()方法

@Override
public void setFloatValues(float... values) {
    // 第一次调用时，values为null
    if (mValues == null || mValues.length == 0) {
        // No values yet - this animator is being constructed piecemeal. Init the values with
        // whatever the current propertyName is
        // 我们设置了mPropertyName，在这里mProperty为null
        if (mProperty != null) {
            setValues(PropertyValuesHolder.ofFloat(mProperty, values));
        } else {
            setValues(PropertyValuesHolder.ofFloat(mPropertyName, values));
        }
    } else {
        super.setFloatValues(values);
    }
}

在setValues之前先调用PropertyValuesHolder.ofFloat(mPropertyName, values)方法初始化PropertyValuesHolder对象

3.1.5 PropertyValuesHolder.ofFloat方法

// 静态方法构造FloatPropertyValuesHolder
public static PropertyValuesHolder ofFloat(String propertyName, float... values) {
    return new FloatPropertyValuesHolder(propertyName, values);
}

调用FloatPropertyValuesHolder构造方法

// FloatPropertyValuesHolder构造方法
public FloatPropertyValuesHolder(String propertyName, float... values) {
    super(propertyName);
    // 调用FloatPropertyValuesHolder.setFloatValues方法
    setFloatValues(values);
}

调用FloatPropertyValuesHolder的setFloatValues()方法

// FloatPropertyValuesHolder
@Override
public void setFloatValues(float... values) {
    // 调用PropertyValuesHolder.setFloatValues方法
    super.setFloatValues(values);
    mFloatKeyframes = (Keyframes.FloatKeyframes) mKeyframes;
}

调用父类PropertyValuesHolder的setFloatValues()方法初始化关键帧集合

// PropertyValuesHolder.setFloatValues
public void setFloatValues(float... values) {
    // 记录mValueType值，便于使用反射方式遍历获取目标target对应的set和get方法
    // 具体可以看getPropertyFunction方法
    mValueType = float.class;
    mKeyframes = KeyframeSet.ofFloat(values);
}

然后设置mKeyframes，KeyFrame是属性动画中的关键帧，通过设置关键帧来保证动画执行的时序性

3.1.6 KeyframeSet.ofFloat()方法

// 静态方法KeyframeSet.ofFloat
public static KeyframeSet ofFloat(float... values) {
    boolean badValue = false;
    int numKeyframes = values.length;
    // 至少初始化两个关键帧
    FloatKeyframe keyframes[] = new FloatKeyframe[Math.max(numKeyframes,2)];
    // 如果values只有一个数值时，那么只有开始和结束这两个关键帧
    if (numKeyframes == 1) {
        keyframes[0] = (FloatKeyframe) Keyframe.ofFloat(0f);
        // 当values只有一个数值时，作为结束帧
        keyframes[1] = (FloatKeyframe) Keyframe.ofFloat(1f, values[0]);
        // 判断values中的数值是否是有效值
        if (Float.isNaN(values[0])) {
            badValue = true;
        }
    } else {
        // 给values中的每一个数值都设置一个关键帧
        keyframes[0] = (FloatKeyframe) Keyframe.ofFloat(0f, values[0]);
        for (int i = 1; i < numKeyframes; ++i) {
            keyframes[i] =
                    (FloatKeyframe) Keyframe.ofFloat((float) i / (numKeyframes - 1), values[i]);
            if (Float.isNaN(values[i])) {
                badValue = true;
            }
        }
    }
    // 当values数值不是有效值时，打印出日志，但是不做其他处理
    if (badValue) {
        Log.w("Animator", "Bad value (NaN) in float animator");
    }
    return new FloatKeyframeSet(keyframes);
}

接下来我们看一下关键帧Keyframe是如何创建的

public static Keyframe ofFloat(float fraction, float value) {
    return new FloatKeyframe(fraction, value);
}

在FloatKeyFrame构造函数中保存fraction和value等值

FloatKeyframe(float fraction, float value) {
    mFraction = fraction;
    mValue = value;
    mValueType = float.class;
    mHasValue = true;
}

KeyFrame其实只是对当前的fraction和value做了一个保存作用，mValueType就是根据不同类型的KeyFrame设置不同的值，这里设置了float.class值

KeyFrame下面，我们接着看KeyframeSet.ofFloat方法，最终会创建一个关键帧的集合FloatKeyframeSet

public FloatKeyframeSet(FloatKeyframe... keyframes) {
    // 调用父类KeyframeSet的构造方法
    super(keyframes);
}

public KeyframeSet(Keyframe... keyframes) {
    mNumKeyframes = keyframes.length;
    // immutable list
    mKeyframes = Arrays.asList(keyframes);
    mFirstKeyframe = keyframes[0];
    mLastKeyframe = keyframes[mNumKeyframes - 1];
    mInterpolator = mLastKeyframe.getInterpolator();
}

ObjectAnimator.ofFloat的过程就结束了，下面我们一起来看其他方法

3.2 分析ObjectAnimator.setDuration()方法

setDuration()用于设置动画执行的时间，这个方法比较简单

public ValueAnimator setDuration(long duration) {
    // 检查duration，小于零则抛出异常
    if (duration < 0) {
        throw new IllegalArgumentException("Animators cannot have negative duration: " +
                duration);
    }
    // 使用mUnscaledDuration保存未做缩放的动画执行时间
    mUnscaledDuration = duration;
    // 计算经过缩放的动画执行时间，默认情况下mDuration=duration
    updateScaledDuration();
    return this;
}

3.3 ObjectAnimator.setInterpolator()方法

setInterpolator()设置动画执行时使用到的插值器，默认的插值器是带有加减速度的插值器

// The time interpolator to be used if none is set on the animation
private static final TimeInterpolator sDefaultInterpolator =
        new AccelerateDecelerateInterpolator();

@Override
public void setInterpolator(TimeInterpolator value) {
    if (value != null) {
        mInterpolator = value;
    } else {
        // value为空时，使用线性插值器
        mInterpolator = new LinearInterpolator();
    }
}

3.4 接下分析ObjectAnimator.start()方法

start()方法是ObjectAnimator中最重要的一个方法，控制着属性动画的启动，这里是见证奇迹的地方，不管你会不会激动，反正我是激动了。

3.4.1 从ObjectAnimator.start()方法开始

@Override
public void start() {
    // See if any of the current active/pending animators need to be canceled
    AnimationHandler handler = sAnimationHandler.get();
    // 第一次启动，handler为空
    if (handler != null) {
        // 通过遍历mAnimations队列来cancel当前动画
        int numAnims = handler.mAnimations.size();
        for (int i = numAnims - 1; i >= 0; i--) {
            if (handler.mAnimations.get(i) instanceof ObjectAnimator) {
                ObjectAnimator anim = (ObjectAnimator) handler.mAnimations.get(i);
                if (anim.mAutoCancel && hasSameTargetAndProperties(anim)) {
                    anim.cancel();
                }
            }
        }
        // 通过遍历mPendingAnimations队列来cancel当前动画
        numAnims = handler.mPendingAnimations.size();
        for (int i = numAnims - 1; i >= 0; i--) {
            if (handler.mPendingAnimations.get(i) instanceof ObjectAnimator) {
                ObjectAnimator anim = (ObjectAnimator) handler.mPendingAnimations.get(i);
                if (anim.mAutoCancel && hasSameTargetAndProperties(anim)) {
                    anim.cancel();
                }
            }
        }
        // 通过遍历mDelayedAnims队列来cancel当前动画
        numAnims = handler.mDelayedAnims.size();
        for (int i = numAnims - 1; i >= 0; i--) {
            if (handler.mDelayedAnims.get(i) instanceof ObjectAnimator) {
                ObjectAnimator anim = (ObjectAnimator) handler.mDelayedAnims.get(i);
                if (anim.mAutoCancel && hasSameTargetAndProperties(anim)) {
                    anim.cancel();
                }
            }
        }
    }
    if (DBG) {
        Log.d(LOG_TAG, "Anim target, duration: " + getTarget() + ", " + getDuration());
        for (int i = 0; i < mValues.length; ++i) {
            PropertyValuesHolder pvh = mValues[i];
            Log.d(LOG_TAG, "   Values[" + i + "]: " +
                pvh.getPropertyName() + ", " + pvh.mKeyframes.getValue(0) + ", " +
                pvh.mKeyframes.getValue(1));
        }
    }
    // 转到ValueAnimator的start()方法
    super.start();
}

AnimationHandler有三个重要的参数：mAnimations、mPendingAnimations以及mDelayedAnims，具体如下：

• mAnimations是一个用来保存当前正在执行的动画列表，

• mPendingAnimation是一个用来保存已经调用了start(boolean playBackwards)方法加入进来的动画列表，不管是否设置mStartDelay延迟时间，都会加入到此列表中
• mDelayedAnims是一个用来保存设置了mStartDelay延迟时间的动画列表，mStartDelay要大于零

3.4.2 最终调用到ValueAnimator.start(boolean playBackwards)方法

// playBackwards表示是否倒序播放，这里我们传入的是false
private void start(boolean playBackwards) {
    if (Looper.myLooper() == null) {
        throw new AndroidRuntimeException("Animators may only be run on Looper threads");
    }
    mReversing = playBackwards;
    mPlayingBackwards = playBackwards;
    // 此时playBackwards为false，第一次启动动画时mSeekFraction为-1，不会进入
    if (playBackwards && mSeekFraction != -1) {
        if (mSeekFraction == 0 && mCurrentIteration == 0) {
            // special case: reversing from seek-to-0 should act as if not seeked at all
            mSeekFraction = 0;
        } else if (mRepeatCount == INFINITE) {
            mSeekFraction = 1 - (mSeekFraction % 1);
        } else {
            mSeekFraction = 1 + mRepeatCount - (mCurrentIteration + mSeekFraction);
        }
        mCurrentIteration = (int) mSeekFraction;
        mSeekFraction = mSeekFraction % 1;
    }
    if (mCurrentIteration > 0 && mRepeatMode == REVERSE &&
            (mCurrentIteration < (mRepeatCount + 1) || mRepeatCount == INFINITE)) {
        // if we were seeked to some other iteration in a reversing animator,
        // figure out the correct direction to start playing based on the iteration
        if (playBackwards) {
            mPlayingBackwards = (mCurrentIteration % 2) == 0;
        } else {
            mPlayingBackwards = (mCurrentIteration % 2) != 0;
        }
    }
    int prevPlayingState = mPlayingState;
    mPlayingState = STOPPED;
    // 在调用start方法之后，mStarted状态改为true
    mStarted = true;
    mStartedDelay = false;
    mPaused = false;
    updateScaledDuration(); // in case the scale factor has changed since creation time
    AnimationHandler animationHandler = getOrCreateAnimationHandler();
    // 把当前动画加入到animationHandler.mPendingAnimation队列中
    animationHandler.mPendingAnimations.add(this);
    // 此处启动动画，等一下分析
  if (mStartDelay == 0) {
        // This sets the initial value of the animation, prior to actually starting it running
        if (prevPlayingState != SEEKED) {
            // 第一次启动，设置当前启动时间为0
            setCurrentPlayTime(0);
        }
        mPlayingState = STOPPED;
        mRunning = true;
        // 回调AnimatorListener.onAnimationStart()方法通知用户
        notifyStartListeners();
    }
    animationHandler.start();
}

这里代码量有点多，主要是根据是否设置动画循环播放来设置标志位和状态，在start方法中调用ValueAnimator.setCurrentPlayTime()方法来设置动画的播放时间

3.4.3 紧接着进入ValueAnimator.setCurrentPlayTime()方法

// ValueAnimator
public void setCurrentPlayTime(long playTime) {
    // mUnscaledDuration就是我们设置的动画执行时间，这里为5000毫秒
    // 第一次执行时，我们的playTime传进来就是0
    float fraction = mUnscaledDuration > 0 ? (float) playTime / mUnscaledDuration : 1;
    // 第一次执行时，fraction=0,调用ValueAnimator.setCurrentFraction()方法
    setCurrentFraction(fraction);
}

3.4.4 调用到ValueAnimator.setCurrentFraction()方法

接下来一起进入setCurrentFraction(float fraction)方法

public void setCurrentFraction(float fraction) {
    // 接下来马上分析
    initAnimation();
    // 此时传进来的fraction=0
    if (fraction < 0) {
        fraction = 0;
    }
    int iteration = (int) fraction;
    // 循环动画时才会进入
    if (fraction == 1) {
        iteration -= 1;
    } else if (fraction > 1) {
        if (iteration < (mRepeatCount + 1) || mRepeatCount == INFINITE) {
            if (mRepeatMode == REVERSE) {
                mPlayingBackwards = (iteration % 2) != 0;
            }
            fraction = fraction % 1f;
        } else {
            fraction = 1;
            iteration -= 1;
        }
    } else {
        mPlayingBackwards = mReversing;
    }
    mCurrentIteration = iteration;
    // 默认情况下，sDurationScale为1.0f，这里mDuration就是我们设置的动画执行时间5000ms
    long seekTime = (long) (mDuration * fraction);
    // 获取当前动画执行的时间点
    long currentTime = AnimationUtils.currentAnimationTimeMillis();
    // 计算当前动画已经执行的时长
    mStartTime = currentTime - seekTime;
    mStartTimeCommitted = true; // do not allow start time to be compensated for jank
    if (mPlayingState != RUNNING) {
        mSeekFraction = fraction;
        mPlayingState = SEEKED;
    }
    if (mPlayingBackwards) {
        fraction = 1f - fraction;
    }
    animateValue(fraction);
}

从上面的代码分析来看，其中调用到了两个方法，分别是initAnimation()和animateValue(fraction)方法

3.4.5 我们先来看ObjectAnimator.initAnimation()方法

@Override
// ObjectAnimator
void initAnimation() {
    // 第一次执行时，mInitialized为false,初始化后该标志位置为true，可以避免多次init
    if (!mInitialized) {
        // mValueType may change due to setter/getter setup; do this before calling super.init(),
        // which uses mValueType to set up the default type evaluator.
        final Object target = getTarget();
        if (target != null) {
            final int numValues = mValues.length;
            for (int i = 0; i < numValues; ++i) {
                // 执行PropertyValuesHolder的setupSetterAndGetter()方法
                mValues[i].setupSetterAndGetter(target);
            }
        }
        super.initAnimation();
    }
}

3.4.6 分析PropertyValuesHolder.setupSetterAndGetter()

PropertyValuesHolder.setupSetterAndGetter(Object target)方法，主要是初始化反射方法mSetter和mGetter

// PropertyValuesHolder
void setupSetterAndGetter(Object target) {
    mKeyframes.invalidateCache();
    // 按照上面的例子，我们设置的是mPropertyName,mProperty为null，不会进去
    if (mProperty != null) {
        // check to make sure that mProperty is on the class of target
        try {
            Object testValue = null;
            List<Keyframe> keyframes = mKeyframes.getKeyframes();
            int keyframeCount = keyframes == null ? 0 : keyframes.size();
            for (int i = 0; i < keyframeCount; i++) {
                Keyframe kf = keyframes.get(i);
                if (!kf.hasValue() || kf.valueWasSetOnStart()) {
                    if (testValue == null) {
                        testValue = convertBack(mProperty.get(target));
                    }
                    kf.setValue(testValue);
                    kf.setValueWasSetOnStart(true);
                }
            }
            return;
        } catch (ClassCastException e) {
            Log.w("PropertyValuesHolder","No such property (" + mProperty.getName() +
                    ") on target object " + target + ". Trying reflection instead");
            mProperty = null;
        }
    }
    // We can't just say 'else' here because the catch statement sets mProperty to null.
    // mProperty为空，判断get和set方法是否存在
    if (mProperty == null) {
        Class targetClass = target.getClass();
        if (mSetter == null) {
            // 查找目标属性的set方法，初始化mSetter方法
            setupSetter(targetClass);
        }
        // 遍历关键帧集合
        List<Keyframe> keyframes = mKeyframes.getKeyframes();
        int keyframeCount = keyframes == null ? 0 : keyframes.size();
        for (int i = 0; i < keyframeCount; i++) {
            Keyframe kf = keyframes.get(i);
            if (!kf.hasValue() || kf.valueWasSetOnStart()) {
                if (mGetter == null) {
                    // 查找目标属性的get方法，初始化mGetter方法
                    setupGetter(targetClass);
                    // mGetter为null时，直接return
                    if (mGetter == null) {
                        // Already logged the error - just return to avoid NPE
                        return;
                    }
                }
                try {
                    // 通过mGetter反射获取属性值
                    Object value = convertBack(mGetter.invoke(target));
                    // 初始化关键帧Keyframe的mValue值
                    kf.setValue(value);
                    // 设置Keyframe标志位为true，表示已经初始化mValue
                    kf.setValueWasSetOnStart(true);
                } catch (InvocationTargetException e) {
                    Log.e("PropertyValuesHolder", e.toString());
                } catch (IllegalAccessException e) {
                    Log.e("PropertyValuesHolder", e.toString());
                }
            }
        }
    }
}

在上面代码中调用到setupSetter和setupGetter方法，这个两个方法最终都是调用setupSetterOrGetter方法

3.4.7 分析PropertyValuesHolder.setupSetterOrGetter()

// 参数prefix值为“set”或者“get”,在这里valueType为float.class
private Method setupSetterOrGetter(Class targetClass,
        HashMap<Class, HashMap<String, Method>> propertyMapMap,
        String prefix, Class valueType) {
    Method setterOrGetter = null;
    // 进行同步锁判断
    synchronized(propertyMapMap) {
        // Have to lock property map prior to reading it, to guard against
        // another thread putting something in there after we've checked it
        // but before we've added an entry to it
        // 根据targetClass获取HashMap，这个propertyMap是以mPropertyName为key，set或者get方法作为value
        // 在这里mPropertyName为"alpha"
        HashMap<String, Method> propertyMap = propertyMapMap.get(targetClass);
        boolean wasInMap = false;
        if (propertyMap != null) {
            wasInMap = propertyMap.containsKey(mPropertyName);
            if (wasInMap) {
                setterOrGetter = propertyMap.get(mPropertyName);
            }
        }
        // 第一次初始化，wasInMap为false
        if (!wasInMap) {
            // 初始化setterOrGetter
            setterOrGetter = getPropertyFunction(targetClass, prefix, valueType);
            if (propertyMap == null) {
                propertyMap = new HashMap<String, Method>();
                propertyMapMap.put(targetClass, propertyMap);
            }
            propertyMap.put(mPropertyName, setterOrGetter);
        }
    }
    return setterOrGetter;
}

在setupSetterOrGetter方法中调用到了getPropertyFunction函数来初始化mSetter或者mGetter参数

3.4.8 接下来分析PropertyValuesHolder.getPropertyFunction()

private Method getPropertyFunction(Class targetClass, String prefix, Class valueType) {
    // TODO: faster implementation...
    Method returnVal = null;
    // 通过prefix和mPropertyName拼接出方法名，如setAlpha或者getAlpha
    String methodName = getMethodName(prefix, mPropertyName);
    Class args[] = null;
    // valueType为Float.class
    if (valueType == null) {
        try {
            returnVal = targetClass.getMethod(methodName, args);
        } catch (NoSuchMethodException e) {
            // Swallow the error, log it later
        }
    } else {
        args = new Class[1];
        Class typeVariants[]; 
        // typeVariants为FLOAT_VARIANTS
        if (valueType.equals(Float.class)) {
            typeVariants = FLOAT_VARIANTS;
        } else if (valueType.equals(Integer.class)) {
            typeVariants = INTEGER_VARIANTS;
        } else if (valueType.equals(Double.class)) {
            typeVariants = DOUBLE_VARIANTS;
        } else {
            typeVariants = new Class[1];
            typeVariants[0] = valueType;
        }
        // FLOAT_VARIANTS,遍历含有float.class、Float.class、double.class、Double.class等参数的方法
        // 只要是相关的基本类型，都会遍历反射查找set或者get方法，看到这里是不是感觉太神奇了
        for (Class typeVariant : typeVariants) {
            args[0] = typeVariant;
            try {
                // 反射获取方法，成功则直接返回
                returnVal = targetClass.getMethod(methodName, args);
                if (mConverter == null) {
                    // change the value type to suit
                    mValueType = typeVariant;
                }
                return returnVal;
            } catch (NoSuchMethodException e) {
                // Swallow the error and keep trying other variants
            }
        }
        // If we got here, then no appropriate function was found
    }

    if (returnVal == null) {
        Log.w("PropertyValuesHolder", "Method " +
                getMethodName(prefix, mPropertyName) + "() with type " + valueType +
                " not found on target class " + targetClass);
    }

    return returnVal;
}

PropertyValuesHolder.setupSetterAndGetter方法已经分析完毕，回到ObjectAnimator.initAnimation()方法中来，遍历mValues初始化关键帧Keyframe的mSetter、mGetter和初始值，发现还会调用父类ValueAnimator.initAnimation()方法

3.4.9 接下来分析ValueAnimator.initAnimation()

// ValueAnimator.initAnimator方法
void initAnimation() {
    if (!mInitialized) {
        int numValues = mValues.length;
        // 遍历mValues，调用PropertyValuesHolder.init()方法
        for (int i = 0; i < numValues; ++i) {
            mValues[i].init();
        }
        mInitialized = true;
    }
}

3.4.10 PropertyValuesHolder中的init方法

// PropertyValuesHolder
void init() {
    // 初始化估值器
    if (mEvaluator == null) {
        // We already handle int and float automatically, but not their Object
        // equivalents
        mEvaluator = (mValueType == Integer.class) ? sIntEvaluator :
                (mValueType == Float.class) ? sFloatEvaluator :
                null;
    }
    if (mEvaluator != null) {
        // KeyframeSet knows how to evaluate the common types - only give it a custom
        // evaluator if one has been set on this class
        // 给关键帧设置估值器
        mKeyframes.setEvaluator(mEvaluator);
    }
}

3.4.11 然后来分析ObjectAnimator.animateValue()方法

ObjectAnimator的initAnimatation过程已经完毕，接下来我们继续回到ValueAnimator.setCurrentFraction(float fraction)方法，最后调用了ObjectAnimator.animateValue(float fraction)，这是一个很重要的方法，主要是通过反射的方式来修改目标mTarget的属性值，这里即是alpha值，在后面中会提到，这里可以先记录一下

@Override
// ObjectAnimator
void animateValue(float fraction) {
    final Object target = getTarget();
    // mTarget是一个软引用，判断target是否已经被回收
    if (mTarget != null && target == null) {
        // We lost the target reference, cancel and clean up.
        cancel();
        return;
    }

    // 这里调用父类ValueAnimator的animateValue来计算数值
    super.animateValue(fraction);
    int numValues = mValues.length;
    for (int i = 0; i < numValues; ++i) {
        // 反射修改每一个属性值，这里修改完这一轮动画就结束了
        mValues[i].setAnimatedValue(target);
    }
}

分析可以看出，如果软引用mTarget已经被回收，就直接调用cancel方法后return，不再执行动画刷新动作；

上面调用父类ValueAnimator中的animateValue方法来进行插值计算

// ValueAnimator
void animateValue(float fraction) {
    // 通过插值器进行计算
    fraction = mInterpolator.getInterpolation(fraction);
    // 获取当前的fraction值
    mCurrentFraction = fraction;
    int numValues = mValues.length;
    for (int i = 0; i < numValues; ++i) {
        // 对每一个PropertyValuesHolder计算数值
        mValues[i].calculateValue(fraction);
    }
    if (mUpdateListeners != null) {
        int numListeners = mUpdateListeners.size();
        for (int i = 0; i < numListeners; ++i) {
            // 回调mUpdateListeners监听器
            mUpdateListeners.get(i).onAnimationUpdate(this);
        }
    }
}

回到子类ObjectAnimator的animateValue(float fraction)方法，遍历mValues调用PropertyValuesHolder.setAnimatedValue(target)方法，通过反射方式来修改target的属性值，上面的例子我们是通过PropertyValuesHolder.ofFloat来创建FloatPropertyValuesHolder,那么调用的就是FloatPropertyValuesHolder的setAnimatedValue方法

3.4.12 FloatPropertyValuesHolder.setAnimatedValue

@Override
void setAnimatedValue(Object target) {
    // 我们传进来的是mPropertyName
    if (mFloatProperty != null) {
        mFloatProperty.setValue(target, mFloatAnimatedValue);
        return;
    }
    if (mProperty != null) {
        mProperty.set(target, mFloatAnimatedValue);
        return;
    }
    // 针对jni属性
    if (mJniSetter != 0) {
        nCallFloatMethod(target, mJniSetter, mFloatAnimatedValue);
        return;
    }
    // 终于到了，反射修改属性值就在这里执行的
    if (mSetter != null) {
        try {
            mTmpValueArray[0] = mFloatAnimatedValue;
            mSetter.invoke(target, mTmpValueArray);
        } catch (InvocationTargetException e) {
            Log.e("PropertyValuesHolder", e.toString());
        } catch (IllegalAccessException e) {
            Log.e("PropertyValuesHolder", e.toString());
        }
    }
}

在这里，我们已经把setCurrentPlayTime()方法分析完毕，回到ValueAnimator.start(boolean playBackwards)方法中，最后一行调用到了AnimationHandlers.start()方法，这里是启动动画执行，在mDuration时间内，通过间隔时间来更新目标的属性值，从而实现一系列的动画变化效果。接下来我们一起来分析AnimationHandlers.start()方法，一起来探究是怎么实现在mDuration时间内来实现动画变化效果的。

3.4.13 AnimationHandlers.start()启动动画执行

// AnimationHandlers.start()
public void start() {
    scheduleAnimation();
}

// AnimationHandlers.scheduleAnimation()
private void scheduleAnimation() {
    if (!mAnimationScheduled) {
        mChoreographer.postCallback(Choreographer.CALLBACK_ANIMATION, mAnimate, null);
        // mAnimationScheduled置为true,控制动画执行，避免在同一帧渲染中重复执行
        mAnimationScheduled = true;
    }
}

start()方法最终是调用scheduleAnimation()方法，分析scheduleAnimation()方法可以得出，是通过mChoreographer的postCallback方法来启动动画执行的，相当于起了一个定时器来不断更新属性值alpha来实现动画刷新，那么mChoreographer是干嘛的呢，有兴趣的可以去看一下其实现的源码深入了解一下

在这里我简单描述一下，Choreographer这个类是用来控制同步处理输入(Input)、动画(Animation)以及绘制(Draw)三个UI操作的，通过接收显示系统的时间脉冲(垂直同步信号-VSync信号)，在下一个Frame渲染时控制执行这些操作。

上面的代码中

mChoreographer.postCallback(Choreographer.CALLBACK_ANIMATION, mAnimate, null);

参数mAnimate是一个Runnable，其实是在下一个帧进行渲染时，Choreographer执行这个Runnable(即mAnimate的run方法)

// Called by the Choreographer.
final Runnable mAnimate = new Runnable() {
    @Override
    public void run() {
        // mAnimationScheduled置为false
        mAnimationScheduled = false;
        doAnimationFrame(mChoreographer.getFrameTime());
    }
};

从mAnimate的实现可以看到，最终会调到AnimatationHandlers的doAnimationFrame(long frameTime)方法

3.1.14 分析AnimatationHandlers.doAnimationFrame方法是如何实现动画刷新的

// AnimatationHandlers
void doAnimationFrame(long frameTime) {
    mLastFrameTime = frameTime;

    // mPendingAnimations holds any animations that have requested to be started
    // We're going to clear mPendingAnimations, but starting animation may
    // cause more to be added to the pending list (for example, if one animation
    // starting triggers another starting). So we loop until mPendingAnimations
    // is empty.
    // 循环判断mPendingAnimations列表是否有数据
    while (mPendingAnimations.size() > 0) {
        // 备份mPendingAnimations列表
        ArrayList<ValueAnimator> pendingCopy =
                (ArrayList<ValueAnimator>) mPendingAnimations.clone();
        // 清空mPendingAnimations列表
        mPendingAnimations.clear();
        int count = pendingCopy.size();
        // 遍历pendingCopy
        for (int i = 0; i < count; ++i) {
            ValueAnimator anim = pendingCopy.get(i);
            // If the animation has a startDelay, place it on the delayed list
            // animation如果设置了mStartDelay时间，加入到mDelayedAnims队列中             // 以便在下一个Frame渲染时遍历查看mStartDelay时间是否已经到了
            if (anim.mStartDelay == 0) {
                anim.startAnimation(this);
            } else {
                mDelayedAnims.add(anim);
            }
        }
    }

    // Next, process animations currently sitting on the delayed queue, adding
    // them to the active animations if they are ready
    int numDelayedAnims = mDelayedAnims.size();
    // 遍历mDelayedAnims队列，判断mStartDelay时间是否已经到了，如果是的话则暂存到mReadyAnims队列中
    for (int i = 0; i < numDelayedAnims; ++i) {
        ValueAnimator anim = mDelayedAnims.get(i);
        // 判断anime的mStartDelay时间是否到期
        if (anim.delayedAnimationFrame(frameTime)) {
            // 把anim加入到mReadyAnims队列中
            mReadyAnims.add(anim);
        }
    }
    int numReadyAnims = mReadyAnims.size();
    // mReadyAnims保存的就是mDelayedAnims队列中delay时间已经到期的animator，遍历mReadyAnims队列
    if (numReadyAnims > 0) {
        for (int i = 0; i < numReadyAnims; ++i) {
            ValueAnimator anim = mReadyAnims.get(i);
            anim.startAnimation(this);
            anim.mRunning = true;
            mDelayedAnims.remove(anim);
        }
        // 清空mReadyAnims
        mReadyAnims.clear();
    }

    // Now process all active animations. The return value from animationFrame()
    // tells the handler whether it should now be ended
    // 把mAnimations队列中的数据备份到mTmpAnimations队列中
    int numAnims = mAnimations.size();
    for (int i = 0; i < numAnims; ++i) {
        mTmpAnimations.add(mAnimations.get(i));
    }
    // 遍历mTmpAnimations队列
    for (int i = 0; i < numAnims; ++i) {
        ValueAnimator anim = mTmpAnimations.get(i);
        // 判断anim动画是否执行完毕，则加入到mEndingAnims队列中
        if (mAnimations.contains(anim) && anim.doAnimationFrame(frameTime)) {
            mEndingAnims.add(anim);
        }
    }
    // 清空mTmpAnimations
    mTmpAnimations.clear();
    // 遍历mEndingAnims队列，调用ValueAnimator的endAnimation方法
    if (mEndingAnims.size() > 0) {
        for (int i = 0; i < mEndingAnims.size(); ++i) {
            mEndingAnims.get(i).endAnimation(this);
        }
        mEndingAnims.clear();
    }

    // Schedule final commit for the frame.
    // 更新ValueAnimator的mStartTime时间，暂时不去看
    mChoreographer.postCallback(Choreographer.CALLBACK_COMMIT, mCommit, null);

    // If there are still active or delayed animations, schedule a future call to
    // onAnimate to process the next frame of the animations.
    // 如果还有动画正在执行，或者还有未执行的动画，则调用scheduleAnimation方法
    if (!mAnimations.isEmpty() || !mDelayedAnims.isEmpty()) {
        scheduleAnimation();
    }
}

这里代码量有点多，我们先分析在遍历mPendingAnimations和mDelayedAnims队列时，都调用到ValueAnimator的startAnimation(AnimationHandler handler)方法，下面我们一起来分析

3.4.15 ValueAnimator.startAnimation方法

// ValueAnimator
private void startAnimation(AnimationHandler handler) {
    if (Trace.isTagEnabled(Trace.TRACE_TAG_VIEW)) {
        Trace.asyncTraceBegin(Trace.TRACE_TAG_VIEW, getNameForTrace(),
                System.identityHashCode(this));
    }
    // 注意到没有，这里又调用到了ObjectAnimator的initAnimation方法
    initAnimation();
    // 把当前正在执行的动画加入到AnimationHandler的mAnimations队列中
    handler.mAnimations.add(this);
    if (mStartDelay > 0 && mListeners != null) {
        // Listeners were already notified in start() if startDelay is 0; this is
        // just for delayed animations
        notifyStartListeners();
    }
}

在上面的代码中，大家注意到了没有，在startAnimation方法中调用到了ObjectAnimator的initAnimation()方法，这个initAnimation方法在上面已经分析了，回过头来看一下，这个initAnimation方法就是初始化动画执行过程用到的参数值，如关键帧Keyframe、get和set方法。那么在上面ObjectAnimator.start()方法中已经初始化了，为什么这里还要调用呢，这是为了使设置了mStartDelay延迟时间的Animator进行初始化调用的。

回到AnimatationHandlers的doAnimationFrame(long frameTime)方法中，在遍历mTmpAnimations队列时，调用了ValueAnimator的doAnimationFrame(long frameTime)，接下来我们一起来看一下是怎么实现的

3.4.16 探究ValueAnimator.doAnimationFrame()方法

// ValueAnimator
final boolean doAnimationFrame(long frameTime) {
    // mPlayingState状态改变
    if (mPlayingState == STOPPED) {
        mPlayingState = RUNNING;
        if (mSeekFraction < 0) {
            mStartTime = frameTime;
        } else {
            long seekTime = (long) (mDuration * mSeekFraction);
            mStartTime = frameTime - seekTime;
            mSeekFraction = -1;
        }
        mStartTimeCommitted = false; // allow start time to be compensated for jank
    }
    if (mPaused) {
        if (mPauseTime < 0) {
            mPauseTime = frameTime;
        }
        return false;
    } else if (mResumed) {
        mResumed = false;
        if (mPauseTime > 0) {
            // Offset by the duration that the animation was paused
            mStartTime += (frameTime - mPauseTime);
            mStartTimeCommitted = false; // allow start time to be compensated for jank
        }
    }
    // The frame time might be before the start time during the first frame of
    // an animation.  The "current time" must always be on or after the start
    // time to avoid animating frames at negative time intervals.  In practice, this
    // is very rare and only happens when seeking backwards.
    final long currentTime = Math.max(frameTime, mStartTime);
    return animationFrame(currentTime);
}

在最后一行中调用到了ValueAnimator.animationFrame()方法

// ValueAnimator
boolean animationFrame(long currentTime) {
    boolean done = false;
    switch (mPlayingState) {
    case RUNNING:
    case SEEKED:
        // 计算fraction
        float fraction = mDuration > 0 ? (float)(currentTime - mStartTime) / mDuration : 1f;
        // 在上面的例子中，mDuration设置为5000ms
        if (mDuration == 0 && mRepeatCount != INFINITE) {
            // Skip to the end
            mCurrentIteration = mRepeatCount;
            if (!mReversing) {
                mPlayingBackwards = false;
            }
        }
        // 这里处理循环动画的情况，我们暂时可以略过
        if (fraction >= 1f) {
            if (mCurrentIteration < mRepeatCount || mRepeatCount == INFINITE) {
                // Time to repeat
                if (mListeners != null) {
                    int numListeners = mListeners.size();
                    for (int i = 0; i < numListeners; ++i) {
                        mListeners.get(i).onAnimationRepeat(this);
                    }
                }
                if (mRepeatMode == REVERSE) {
                    mPlayingBackwards = !mPlayingBackwards;
                }
                mCurrentIteration += (int) fraction;
                fraction = fraction % 1f;
                mStartTime += mDuration;
                // Note: We do not need to update the value of mStartTimeCommitted here
                // since we just added a duration offset.
            } else {
                done = true;
                fraction = Math.min(fraction, 1.0f);
            }
        }
        // 根据上面的例子，mPlayingBackwards为false
        if (mPlayingBackwards) {
            fraction = 1f - fraction;
        }
        // 注意啦，这里调用到ObjectAnimator的animateValue方法
        animateValue(fraction);
        break;
    }

    return done;
}

通过上面的分析，我们注意到，在animationFrame(long currentTime)方法中调用了ObjectAnimator的animateValue(float fraction)，而这个方法我们在上面已经分析过了，终于又回来了，这个animateValue方法主要就是根据fraction计算属性值，然后通过反射的方式修改目标mTarget的alpha属性值，从而达到mTarget的alpha值从0.0到1.0的渐显效果。

终于到了见证奇迹的地方，ObjectAnimator动画执行就是不断的通过mChoreographer的postCallback方法实现在帧渲染时执行mAnimate这个Runnable，在animateValue方法中利用反射方式改变目标target的属性值，从而实现动画效果的。

至此，ObjectAnimator动画执行的过程已经全部完毕。

4.结尾

最后我们回到博客开头我提到的想法，就是如果在ObjectAnimator动画结束回调函数onAnimationEnd中重新start此动画，是否能达到循环播放动画呢？我们仔细分析ValueAnimator的endAnimation(AnimationHandler handler)方法

// ValueAnimator
protected void endAnimation(AnimationHandler handler) {
    // 清空AnimationHandler用到的队列
    handler.mAnimations.remove(this);
    handler.mPendingAnimations.remove(this);
    handler.mDelayedAnims.remove(this);
    mPlayingState = STOPPED;
    mPaused = false;
    if ((mStarted || mRunning) && mListeners != null) {
        if (!mRunning) {
            // If it's not yet running, then start listeners weren't called. Call them now.
            notifyStartListeners();
         }
        ArrayList<AnimatorListener> tmpListeners =
                (ArrayList<AnimatorListener>) mListeners.clone();
        int numListeners = tmpListeners.size();
        for (int i = 0; i < numListeners; ++i) {
            // 回调AnimatorListener.onAnimationEnd,在我的想法中就是在这里重新start动画
            tmpListeners.get(i).onAnimationEnd(this);
        }
    }
    // 这些标志位都置为false
    mRunning = false;
    mStarted = false;
    mStartListenersCalled = false;
    mPlayingBackwards = false;
    mReversing = false;
    mCurrentIteration = 0;
    if (Trace.isTagEnabled(Trace.TRACE_TAG_VIEW)) {
        Trace.asyncTraceEnd(Trace.TRACE_TAG_VIEW, getNameForTrace(),
                System.identityHashCode(this));
    }
}

通过分析，原来在AnimatorListener.onAnimationEnd回调中即使重新start动画，由于当时mStartListenersCalled为true，所以再次start动画时不会在回调AnimatorListener.onAnimationStart方法，在后面又把mRunning和mStarted两个标志位改为false，导致在第二次start的动画结束时调用endAnimation方法中因为这两个标志位都是为false，所以不会再次回调AnimatorListener.onAnimationEnd方法，也就是说重新start起来的动画执行完毕就不会再此触发start动作，所以验证博客开头代码的实验效果。

这篇博客已经完毕，非常感谢您对本篇的关注，希望能对您了解ObjectAnimator属性动画的实现有帮助，要是有不足之处欢迎指正，我们相互讨论学习！