Android動畫可作用於View/ViewGroup，Actvity，Fragment實現炫酷的互動效果。經過幾天的探究，搞清楚了各類動畫的使用和動畫的實現原理，在此記錄以下。
儘管Android動畫有好幾種類別，但是各種動畫的實現核心都是TimeInterpolator->Interpolator->各種Interpolator。大致過程是透過Interpolator計算出時間相關的input，透過這個input計算出各類fraction，利用各類Interpolator計算出的fraction計算出各種狀態引數（時間相關），將這些引數使用到動畫效果上，Android會透過一定的機制不斷重複這個過程(16ms為週期)就構成了我們看到的動畫。

從動畫的分類上有以下幾種類別：

# 1、FrameAnimation

FrameAnimation顧名思義就是幀動畫，透過逐幀播放來實現的動畫。Frame Animation可以透過xml來實現，也可應用程式碼來實現：
xml實現時根結點必須是`<animation-list>`，根結點內包含多個`<item>`元素，例如:

```
<animation-list xmlns:android="http://schemas.android.com/apk/res/android" android:oneshot="["true"">
 <item android:drawable="@drawable/frame1" android:duration="250"></item>
 <item android:drawable="@drawable/frame2" android:duration="250"></item>
 <item android:drawable="@drawable/frame3" android:duration="250"></item>
 <item android:drawable="@drawable/frame4" android:duration="250"></item>
</animation-list>
```

對於這種動畫，就是不斷的更換顯示的Drawable來實現動態效果。

# 2、TweenAnimation

可以對View進行一系列的變換，如平移，翻轉，縮放，淡入淡出，也可以將他們組合起來形成混合的動畫效果。TweenAnimation的實現方式也有兩種，分別可以用程式碼和xml實現。
xml:

```
<?xml version="1.0" encoding="utf-8"?>
<set xmlns:android="http://schemas.android.com/apk/res/android" android:interpolator="@[package:]anim/interpolator_resource" android:shareinterpolator="["true"">
 <alpha android:fromalpha="float" android:toalpha="float"></alpha>
 <scale android:fromxscale="float" android:toxscale="float" android:fromyscale="float" android:toyscale="float" android:pivotx="float" android:pivoty="float"></scale>
 <translate android:fromxdelta="float" android:toxdelta="float" android:fromydelta="float" android:toydelta="float"></translate>
 <rotate android:fromdegrees="float" android:todegrees="float" android:pivotx="float" android:pivoty="float"></rotate>
 <set>
 ...
 </set>
</set>
```

載入xml動畫可以用Android SDK提供的工具類：

```
AnimationUtils.loadAnimations();
```

至於程式碼實現方式：

```
//提供了以下幾種Animation
AlphaAnimation TranslateAnimation ScaleAnimation RotateAnimation
AnimationSet.addAnimation(Animation)
//使用方法基本與定義xml一致
```

Animation的運作依賴兩個方法：

```
 /**
     * 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();
 final long duration = mDuration;
 float normalizedTime;
 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;
 }

final boolean expired = normalizedTime >= 1.0f || isCanceled();
        mMore = !expired;

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

if ((normalizedTime >= 0.0f || mFillBefore) && (normalizedTime <= 1.0f || mFillAfter)) {
 if (!mStarted) {
 fireAnimationStart();
 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);
        }

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();
            }
        }

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

return mMore;
    }

protected void applyTransformation(float interpolatedTime, Transformation t) {
    }
```

每次呼叫getTransformation會計算一個normalizedTime，這個normalizedTime會作為interpolator的input傳到interpolator中：

```
            final float interpolatedTime = mInterpolator.getInterpolation(normalizedTime);
```

得到一個經過inpterpolator計算過的fraction（interpolatedTime）。之後以這個interpolatedTime為引數回撥applyTransformation：

```
applyTransformation(interpolatedTime, outTransformation);
```

applyTransformation的另一引數，outTransformation是一個Transformation物件，其中的兩個成員變數如下：

```
    protected Matrix mMatrix;
    protected float mAlpha;
```

也就是說透過這個outTransformation，可以對它的alpha或者matrix進行運算，然後Android會讀取經過Animation運算的outTransformation裡的這兩個變數然後作用於要實現動畫效果的元件View/ViewGroup，Actvity，Fragment上實現動畫效果。至於如何實現這個過程，下面會有分析。
透過上面的分析得知，Animation的執行依賴Android本身的機制回撥（每幀都得回撥getTransformation和applyTransformation）無法自身進行運算計算fraction，並且可參與運算的只有Transformation物件裡的alpha和matrix，所以Animation只能實現簡單的Alpha，Scale，Translate，Rotate變換效果。

# 3、PropertyAnimator

Android提供了3種，分別是：

```
ObjectAnimator
TimeAnimator
ValueAnimator
```

上面分析的Animation受限於Android本身的回撥，只能實現Alpha，Scale，Translate，Rotate的變換。而Animator沒有此限制，它不依賴於Android本身的機制回撥，但是它意依賴於Looper的Thread，上原始碼：

```
 private void start(boolean playBackwards) {
        if (Looper.myLooper() == null) {
            throw new AndroidRuntimeException("Animators may only be run on Looper threads");
        }
        mReversing = playBackwards;
        // Special case: reversing from seek-to-0 should act as if not seeked at all.
        if (playBackwards && mSeekFraction != -1 && mSeekFraction != 0) {
            if (mRepeatCount == INFINITE) {
                // Calculate the fraction of the current iteration.
                float fraction = (float) (mSeekFraction - Math.floor(mSeekFraction));
                mSeekFraction = 1 - fraction;
            } else {
                mSeekFraction = 1 + mRepeatCount - mSeekFraction;
            }
        }
        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 = 0;
        AnimationHandler animationHandler = AnimationHandler.getInstance();
        animationHandler.addAnimationFrameCallback(this, (long) (mStartDelay * sDurationScale));

if (mStartDelay == 0 || mSeekFraction >= 0) {
            // If there's no start delay, init the animation and notify start listeners right away
            // to be consistent with the previous behavior. Otherwise, postpone this until the first
            // frame after the start delay.
            startAnimation();
            if (mSeekFraction == -1) {
                // No seek, start at play time 0\. Note that the reason we are not using fraction 0
                // is because for animations with 0 duration, we want to be consistent with pre-N
                // behavior: skip to the final value immediately.
                setCurrentPlayTime(0);
            } else {
                setCurrentFraction(mSeekFraction);
            }
        }
    }
```

從start開始分析，從程式碼可知只能在Looper Thread上開啟Animator，一看到Looper我們就瞬間恍然大悟，原來Animator的實現也離不卡Handler機制。

```
AnimationHandler animationHandler = AnimationHandler.getInstance();
        animationHandler.addAnimationFrameCallback(this, (long) (mStartDelay * sDurationScale));
```

Animator獲得一個AnimationHandler例項，並把自身作為回撥傳給這個AnimationHandler：

```
public class ValueAnimator extends Animator implements AnimationHandler.AnimationFrameCallback {
     ...
}
public class AnimationHandler {
    ...

/**
     * Callbacks that receives notifications for animation timing and frame commit timing.
     */
    interface AnimationFrameCallback {
        /**
         * Run animation based on the frame time.
         * @param frameTime The frame start time, in the {@link SystemClock#uptimeMillis()} time
         *                  base.
         */
        void doAnimationFrame(long frameTime);

/**
         * This notifies the callback of frame commit time. Frame commit time is the time after
         * traversals happen, as opposed to the normal animation frame time that is before
         * traversals. This is used to compensate expensive traversals that happen as the
         * animation starts. When traversals take a long time to complete, the rendering of the
         * initial frame will be delayed (by a long time). But since the startTime of the
         * animation is set before the traversal, by the time of next frame, a lot of time would
         * have passed since startTime was set, the animation will consequently skip a few frames
         * to respect the new frameTime. By having the commit time, we can adjust the start time to
         * when the first frame was drawn (after any expensive traversals) so that no frames
         * will be skipped.
         *
         * @param frameTime The frame time after traversals happen, if any, in the
         *                  {@link SystemClock#uptimeMillis()} time base.
         */
        void commitAnimationFrame(long frameTime);
    }
}

```

但是我們發現。。。特麼的這個AnimationHandler根本就不是一個Handler。
重新回到Animator的執行流程上。。。
在start函式里我們看到有一個：

```
animationHandler.addAnimationFrameCallback(this, (long) (mStartDelay * sDurationScale));
```

跟進去：

```
/**
     * 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));
        }
    }
```

發現有這樣一句話：

```
getProvider().postFrameCallback(mFrameCallback);
```

Provider又是什麼呢？

```
private AnimationFrameCallbackProvider getProvider() {
        if (mProvider == null) {
            mProvider = new MyFrameCallbackProvider();
        }
        return mProvider;
    }
```

MyFrameCallbackProvider又是什麼呢？

```
/**
     * Default provider of timing pulse that uses Choreographer for frame callbacks.
     */
    private class MyFrameCallbackProvider implements AnimationFrameCallbackProvider {

final Choreographer mChoreographer = Choreographer.getInstance();

@Override
        public void postFrameCallback(Choreographer.FrameCallback callback) {
            mChoreographer.postFrameCallback(callback);
        }

@Override
        public void postCommitCallback(Runnable runnable) {
            mChoreographer.postCallback(Choreographer.CALLBACK_COMMIT, runnable, null);
        }

@Override
        public long getFrameTime() {
            return mChoreographer.getFrameTime();
        }

@Override
        public long getFrameDelay() {
            return Choreographer.getFrameDelay();
        }

@Override
        public void setFrameDelay(long delay) {
            Choreographer.setFrameDelay(delay);
        }
    }
```

Choreographer又是什麼呢？

```
public final class Choreographer {
 ...
/**
 * Posts a frame callback to run on the next frame.
 * 
 * The callback runs once then is automatically removed.
 * 
 *
 * @param callback The frame callback to run during the next frame.
 *
 * @see #postFrameCallbackDelayed
 * @see #removeFrameCallback
 */
 public void postFrameCallback(FrameCallback callback) {
 postFrameCallbackDelayed(callback, 0);
 }
public void postFrameCallbackDelayed(FrameCallback callback, long delayMillis) {
 if (callback == null) {
 throw new IllegalArgumentException("callback must not be null");
 }

postCallbackDelayedInternal(CALLBACK_ANIMATION,
                callback, FRAME_CALLBACK_TOKEN, delayMillis);
    }
private void postCallbackDelayedInternal(int callbackType,
            Object action, Object token, long delayMillis) {
        if (DEBUG_FRAMES) {
            Log.d(TAG, "PostCallback: type=" + callbackType
                    + ", action=" + action + ", token=" + token
                    + ", delayMillis=" + delayMillis);
        }

synchronized (mLock) {
            final long now = SystemClock.uptimeMillis();
            final long dueTime = now + delayMillis;
            mCallbackQueues[callbackType].addCallbackLocked(dueTime, action, token);

if (dueTime <= now) {
 scheduleFrameLocked(now);
 } else {
 Message msg = mHandler.obtainMessage(MSG_DO_SCHEDULE_CALLBACK, action);
 msg.arg1 = callbackType;
 msg.setAsynchronous(true);
 mHandler.sendMessageAtTime(msg, dueTime);
 }
 }
 }
```

看到這裡。。。終於現出原形了出現了一個mHandler，mHandler又是什麼呢？

```
public final class Choreographer {
    private final FrameHandler mHandler;
    ...
}
它是Choreographer的一個成員變數，從命名上看似乎是一個與Frame（幀）相關的Handler：
```Java
private final class FrameHandler extends Handler {
        public FrameHandler(Looper looper) {
            super(looper);
        }

@Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
                case MSG_DO_FRAME:
                    doFrame(System.nanoTime(), 0);
                    break;
                case MSG_DO_SCHEDULE_VSYNC:
                    doScheduleVsync();
                    break;
                case MSG_DO_SCHEDULE_CALLBACK:
                    doScheduleCallback(msg.arg1);
                    break;
            }
        }
    }
```

但是還有一點：

```
getProvider().postFrameCallback(mFrameCallback);

```

這個mFrameCallback對應的類是：

```
private final Choreographer.FrameCallback mFrameCallback = new Choreographer.FrameCallback() {
        @Override
        public void doFrame(long frameTimeNanos) {
            doAnimationFrame(getProvider().getFrameTime());
            if (mAnimationCallbacks.size() > 0) {
                getProvider().postFrameCallback(this);
            }
        }
    };
```

這又是一系列複雜的callback，分析明白了也寫不明白，但FrameHandler的doFrame最終會呼叫我們的mFrameCallback，也就是會呼叫到doAnimationFrame，最終會呼叫到Animator的animateValue方法。再之後大家都知道了。。。會呼叫AnimatorUpdateListener的onAnimationUpdate。一頓分析，大致過程明白了，但是這個機制也太複雜了，牽扯了太多的方面，太多的類。什麼時候自己能有這樣的設計能力啊。。
關於Choreographer這個類：
*[https://www.cnblogs.com/kross/p/4087780.html](https://link.jianshu.com?t=https%3A%2F%2Fwww.cnblogs.com%2Fkross%2Fp%2F4087780.html)
這篇檔案有比較詳細的分析，暫時還不能理解那麼多。

# 其它的

關於Chroeographer原始碼註釋是這樣寫的：

```
/**
 * Coordinates the timing of animations, input and drawing.
 * 
 * The choreographer receives timing pulses (such as vertical synchronization)
 * from the display subsystem then schedules work to occur as part of rendering
 * the next display frame.
 * 
 * Applications typically interact with the choreographer indirectly using
 * higher level abstractions in the animation framework or the view hierarchy.
 * Here are some examples of things you can do using the higher-level APIs.
 * 
 * <ul>
 * <li>To post an animation to be processed on a regular time basis synchronized with
 * display frame rendering, use {@link android.animation.ValueAnimator#start}.</li>
 * <li>To post a {@link Runnable} to be invoked once at the beginning of the next display
 * frame, use {@link View#postOnAnimation}.</li>
 * <li>To post a {@link Runnable} to be invoked once at the beginning of the next display
 * frame after a delay, use {@link View#postOnAnimationDelayed}.</li>
 * <li>To post a call to {@link View#invalidate()} to occur once at the beginning of the
 * next display frame, use {@link View#postInvalidateOnAnimation()} or
 * {@link View#postInvalidateOnAnimation(int, int, int, int)}.</li>
 * <li>To ensure that the contents of a {@link View} scroll smoothly and are drawn in
 * sync with display frame rendering, do nothing. This already happens automatically.
 * {@link View#onDraw} will be called at the appropriate time.</li>
 * </ul>
 * 
 * However, there are a few cases where you might want to use the functions of the
 * choreographer directly in your application. Here are some examples.
 * 
 * <ul>
 * <li>If your application does its rendering in a different thread, possibly using GL,
 * or does not use the animation framework or view hierarchy at all
 * and you want to ensure that it is appropriately synchronized with the display, then use
 * {@link Choreographer#postFrameCallback}.</li>
 * <li>... and that's about it.</li>
 * </ul>
 * 
 * Each {@link Looper} thread has its own choreographer. Other threads can
 * post callbacks to run on the choreographer but they will run on the {@link Looper}
 * to which the choreographer belongs.
 * 
 */
```

有一句話引起了我的注意：
If your application does its rendering in a different thread, possibly using GL,

*   or does not use the animation framework or view hierarchy at all
    也就是說，通常我們的View只能在建立它的執行緒內進行事件處理，動畫，或者繪製的原因在於，這些框架和機制的實現都依賴於這個類，這個類是執行緒相關。若要在其他執行緒內渲染可以直接使用Choreographer#postFrameCallback？？？
    有待探究。。

文章轉自 https://www.jianshu.com/p/435e9645bc4c ，如有侵權，請聯絡刪除。

#### 相關影片：

[【Android 基礎課程】流行框架之熱修復解讀_嗶哩嗶哩_bilibili](hhttps://www.bilibili.com/video/BV1Br4y1y7tH?p=2&spm_id_from=pageDriver)
[【Android 基礎課程】高階UI進階, 從零到精通(二)_嗶哩嗶哩_bilibili](https://www.bilibili.com/video/BV1Nf4y1g74k?spm_id_from=333.999.0.0)
[【Android進階系統學習——面對層出不窮的第三方SDK，身為架構師該怎麼做？_嗶哩嗶哩_bilibili](https://www.bilibili.com/video/BV1Li4y177f1?spm_id_from=333.999.0.0)
[教你快速成長為一位具備核心競爭力的移動架師_嗶哩嗶哩_bilibili](https://www.bilibili.com/video/BV1G54y1V7XZ?p=2&spm_id_from=pageDriver)
[Android架構師核心技術——請求型框架通用設計方案_嗶哩嗶哩_bilibili](https://www.bilibili.com/video/BV1st4y1i7zZ?spm_id_from=333.999.0.0)</item></animation-list>

Android高階進階之路【三】看完這篇再不會Android動畫框架，我跪搓衣板

相關文章