文章轉(zhuǎn)載至郭神的博客

大家好，在上一篇文章當(dāng)中，我們學(xué)習(xí)了Android屬性動畫的基本用法，當(dāng)然也是最常用的一些用法，這些用法足以覆蓋我們平時大多情況下的動畫需求了。但是，正如上篇文章當(dāng)中所說到的，屬性動畫對補間動畫進(jìn)行了很大幅度的改進(jìn)，之前補間動畫可以做到的屬性動畫也能做到，補間動畫做不到的現(xiàn)在屬性動畫也可以做到了。因此，今天我們就來學(xué)習(xí)一下屬性動畫的高級用法，看看如何實現(xiàn)一些補間動畫所無法實現(xiàn)的功能。

閱讀本篇文章需要你對屬性動畫有一定的了解，并且掌握屬性動畫的基本用法，如果你還對屬性動畫不夠了解的話，建議先去閱讀 Android屬性動畫完全解析(上)，初識屬性動畫的基本用法 。

ValueAnimator的高級用法

在上篇文章中介紹補間動畫缺點的時候有提到過，補間動畫是只能對View對象進(jìn)行動畫操作的。而屬性動畫就不再受這個限制，它可以對任意對象進(jìn)行動畫操作。那么大家應(yīng)該還記得在上篇文章當(dāng)中我舉的一個例子，比如說我們有一個自定義的View，在這個View當(dāng)中有一個Point對象用于管理坐標(biāo)，然后在onDraw()方法當(dāng)中就是根據(jù)這個Point對象的坐標(biāo)值來進(jìn)行繪制的。也就是說，如果我們可以對Point對象進(jìn)行動畫操作，那么整個自定義View的動畫效果就有了。OK，下面我們就來學(xué)習(xí)一下如何實現(xiàn)這樣的效果。

在開始動手之前，我們還需要掌握另外一個知識點，就是TypeEvaluator的用法?？赡茉诖蠖鄶?shù)情況下我們使用屬性動畫的時候都不會用到TypeEvaluator，但是大家還是應(yīng)該了解一下它的用法，以防止當(dāng)我們遇到一些解決不掉的問題時能夠想起來還有這樣的一種解決方案。

那么TypeEvaluator的作用到底是什么呢？簡單來說，就是告訴動畫系統(tǒng)如何從初始值過度到結(jié)束值。我們在上一篇文章中學(xué)到的ValueAnimator.ofFloat()方法就是實現(xiàn)了初始值與結(jié)束值之間的平滑過度，那么這個平滑過度是怎么做到的呢？其實就是系統(tǒng)內(nèi)置了一個FloatEvaluator，它通過計算告知動畫系統(tǒng)如何從初始值過度到結(jié)束值，我們來看一下FloatEvaluator的代碼實現(xiàn)：

public class FloatEvaluator implements TypeEvaluator {  
    public Object evaluate(float fraction, Object startValue, Object endValue) {  
        float startFloat = ((Number) startValue).floatValue();  
        return startFloat + fraction * (((Number) endValue).floatValue() - startFloat);  
    }  
}  

可以看到，F(xiàn)loatEvaluator實現(xiàn)了TypeEvaluator接口，然后重寫evaluate()方法。evaluate()方法當(dāng)中傳入了三個參數(shù)，第一個參數(shù)fraction非常重要，這個參數(shù)用于表示動畫的完成度的，我們應(yīng)該根據(jù)它來計算當(dāng)前動畫的值應(yīng)該是多少，第二第三個參數(shù)分別表示動畫的初始值和結(jié)束值。那么上述代碼的邏輯就比較清晰了，用結(jié)束值減去初始值，算出它們之間的差值，然后乘以fraction這個系數(shù)，再加上初始值，那么就得到當(dāng)前動畫的值了。

好的，那FloatEvaluator是系統(tǒng)內(nèi)置好的功能，并不需要我們自己去編寫，但介紹它的實現(xiàn)方法是要為我們后面的功能鋪路的。前面我們使用過了ValueAnimator的ofFloat()和ofInt()方法，分別用于對浮點型和整型的數(shù)據(jù)進(jìn)行動畫操作的，但實際上ValueAnimator中還有一個ofObject()方法，是用于對任意對象進(jìn)行動畫操作的。但是相比于浮點型或整型數(shù)據(jù)，對象的動畫操作明顯要更復(fù)雜一些，因為系統(tǒng)將完全無法知道如何從初始對象過度到結(jié)束對象，因此這個時候我們就需要實現(xiàn)一個自己的TypeEvaluator來告知系統(tǒng)如何進(jìn)行過度。

下面來先定義一個Point類，如下所示：

public class Point {  
  
    private float x;  
  
    private float y;  
  
    public Point(float x, float y) {  
        this.x = x;  
        this.y = y;  
    }  
  
    public float getX() {  
        return x;  
    }  
  
    public float getY() {  
        return y;  
    }  
  
}  

Point類非常簡單，只有x和y兩個變量用于記錄坐標(biāo)的位置，并提供了構(gòu)造方法來設(shè)置坐標(biāo)，以及get方法來獲取坐標(biāo)。接下來定義PointEvaluator，如下所示：

public class PointEvaluator implements TypeEvaluator{  
  
    @Override  
    public Object evaluate(float fraction, Object startValue, Object endValue) {  
        Point startPoint = (Point) startValue;  
        Point endPoint = (Point) endValue;  
        float x = startPoint.getX() + fraction * (endPoint.getX() - startPoint.getX());  
        float y = startPoint.getY() + fraction * (endPoint.getY() - startPoint.getY());  
        Point point = new Point(x, y);  
        return point;  
    }  
  
}  

可以看到，PointEvaluator同樣實現(xiàn)了TypeEvaluator接口并重寫了evaluate()方法。其實evaluate()方法中的邏輯還是非常簡單的，先是將startValue和endValue強轉(zhuǎn)成Point對象，然后同樣根據(jù)fraction來計算當(dāng)前動畫的x和y的值，最后組裝到一個新的Point對象當(dāng)中并返回。

這樣我們就將PointEvaluator編寫完成了，接下來我們就可以非常輕松地對Point對象進(jìn)行動畫操作了，比如說我們有兩個Point對象，現(xiàn)在需要將Point1通過動畫平滑過度到Point2，就可以這樣寫：

Point point1 = new Point(0, 0);  
Point point2 = new Point(300, 300);  
ValueAnimator anim = ValueAnimator.ofObject(new PointEvaluator(), point1, point2);  
anim.setDuration(5000);  
anim.start();  

代碼很簡單，這里我們先是new出了兩個Point對象，并在構(gòu)造函數(shù)中分別設(shè)置了它們的坐標(biāo)點。然后調(diào)用ValueAnimator的ofObject()方法來構(gòu)建ValueAnimator的實例，這里需要注意的是，ofObject()方法要求多傳入一個TypeEvaluator參數(shù)，這里我們只需要傳入剛才定義好的PointEvaluator的實例就可以了。

好的，這就是自定義TypeEvaluator的全部用法，掌握了這些知識之后，我們就可以來嘗試一下如何通過對Point對象進(jìn)行動畫操作，從而實現(xiàn)整個自定義View的動畫效果。

新建一個MyAnimView繼承自View，代碼如下所示：

public class MyAnimView extends View {  
  
    public static final float RADIUS = 50f;  
  
    private Point currentPoint;  
  
    private Paint mPaint;  
  
    public MyAnimView(Context context, AttributeSet attrs) {  
        super(context, attrs);  
        mPaint = new Paint(Paint.ANTI_ALIAS_FLAG);  
        mPaint.setColor(Color.BLUE);  
    }  
  
    @Override  
    protected void onDraw(Canvas canvas) {  
        if (currentPoint == null) {  
            currentPoint = new Point(RADIUS, RADIUS);  
            drawCircle(canvas);  
            startAnimation();  
        } else {  
            drawCircle(canvas);  
        }  
    }  
  
    private void drawCircle(Canvas canvas) {  
        float x = currentPoint.getX();  
        float y = currentPoint.getY();  
        canvas.drawCircle(x, y, RADIUS, mPaint);  
    }  
  
    private void startAnimation() {  
        Point startPoint = new Point(RADIUS, RADIUS);  
        Point endPoint = new Point(getWidth() - RADIUS, getHeight() - RADIUS);  
        ValueAnimator anim = ValueAnimator.ofObject(new PointEvaluator(), startPoint, endPoint);  
        anim.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {  
            @Override  
            public void onAnimationUpdate(ValueAnimator animation) {  
                currentPoint = (Point) animation.getAnimatedValue();  
                invalidate();  
            }  
        });  
        anim.setDuration(5000);  
        anim.start();  
    }  
  
}  

基本上還是很簡單的，總共也沒幾行代碼。首先在自定義View的構(gòu)造方法當(dāng)中初始化了一個Paint對象作為畫筆，并將畫筆顏色設(shè)置為藍(lán)色，接著在onDraw()方法當(dāng)中進(jìn)行繪制。這里我們繪制的邏輯是由currentPoint這個對象控制的，如果currentPoint對象不等于空，那么就調(diào)用drawCircle()方法在currentPoint的坐標(biāo)位置畫出一個半徑為50的圓，如果currentPoint對象是空，那么就調(diào)用startAnimation()方法來啟動動畫。

那么我們來觀察一下startAnimation()方法中的代碼，其實大家應(yīng)該很熟悉了，就是對Point對象進(jìn)行了一個動畫操作而已。這里我們定義了一個startPoint和一個endPoint，坐標(biāo)分別是View的左上角和右下角，并將動畫的時長設(shè)為5秒。然后有一點需要大家注意的，就是我們通過監(jiān)聽器對動畫的過程進(jìn)行了監(jiān)聽，每當(dāng)Point值有改變的時候都會回調(diào)onAnimationUpdate()方法。在這個方法當(dāng)中，我們對currentPoint對象進(jìn)行了重新賦值，并調(diào)用了invalidate()方法，這樣的話onDraw()方法就會重新調(diào)用，并且由于currentPoint對象的坐標(biāo)已經(jīng)改變了，那么繪制的位置也會改變，于是一個平移的動畫效果也就實現(xiàn)了。

下面我們只需要在布局文件當(dāng)中引入這個自定義控件：

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"  
    android:layout_width="match_parent"  
    android:layout_height="match_parent"  
    >  
  
    <com.example.tony.myapplication.MyAnimView  
        android:layout_width="match_parent"  
        android:layout_height="match_parent" />  
  
</RelativeLayout>  

最后運行一下程序，效果如下圖所示：

OK！這樣我們就成功實現(xiàn)了通過對對象進(jìn)行值操作來實現(xiàn)動畫效果的功能，這就是ValueAnimator的高級用法。

ObjectAnimator的高級用法

ObjectAnimator的基本用法和工作原理在上一篇文章當(dāng)中都已經(jīng)講解過了，相信大家都已經(jīng)掌握。那么大家應(yīng)該都還記得，我們在吐槽補間動畫的時候有提到過，補間動畫是只能實現(xiàn)移動、縮放、旋轉(zhuǎn)和淡入淡出這四種動畫操作的，功能限定死就是這些，基本上沒有任何擴(kuò)展性可言。比如我們想要實現(xiàn)對View的顏色進(jìn)行動態(tài)改變，補間動畫是沒有辦法做到的。

但是屬性動畫就不會受這些條條框框的限制，它的擴(kuò)展性非常強，對于動態(tài)改變View的顏色這種功能是完全可是勝任的，那么下面我們就來學(xué)習(xí)一下如何實現(xiàn)這樣的效果。

大家應(yīng)該都還記得，ObjectAnimator內(nèi)部的工作機(jī)制是通過尋找特定屬性的get和set方法，然后通過方法不斷地對值進(jìn)行改變，從而實現(xiàn)動畫效果的。因此我們就需要在MyAnimView中定義一個color屬性，并提供它的get和set方法。這里我們可以將color屬性設(shè)置為字符串類型，使用#RRGGBB這種格式來表示顏色值，代碼如下所示：

public class MyAnimView extends View {  
  
    ...  
  
    private String color;  
  
    public String getColor() {  
        return color;  
    }  
  
    public void setColor(String color) {  
        this.color = color;  
        mPaint.setColor(Color.parseColor(color));  
        invalidate();  
    }  
  
    ...  
  
}  

注意在setColor()方法當(dāng)中，我們編寫了一個非常簡單的邏輯，就是將畫筆的顏色設(shè)置成方法參數(shù)傳入的顏色，然后調(diào)用了invalidate()方法。這段代碼雖然只有三行，但是卻執(zhí)行了一個非常核心的功能，就是在改變了畫筆顏色之后立即刷新視圖，然后onDraw()方法就會調(diào)用。在onDraw()方法當(dāng)中會根據(jù)當(dāng)前畫筆的顏色來進(jìn)行繪制，這樣顏色也就會動態(tài)進(jìn)行改變了。

那么接下來的問題就是怎樣讓setColor()方法得到調(diào)用了，毫無疑問，當(dāng)然是要借助ObjectAnimator類，但是在使用ObjectAnimator之前我們還要完成一個非常重要的工作，就是編寫一個用于告知系統(tǒng)如何進(jìn)行顏色過度的TypeEvaluator。創(chuàng)建ColorEvaluator并實現(xiàn)TypeEvaluator接口，代碼如下所示：

public class ColorEvaluator implements TypeEvaluator {  
  
    private int mCurrentRed = -1;  
  
    private int mCurrentGreen = -1;  
  
    private int mCurrentBlue = -1;  
  
    @Override  
    public Object evaluate(float fraction, Object startValue, Object endValue) {  
        String startColor = (String) startValue;  
        String endColor = (String) endValue;  
        int startRed = Integer.parseInt(startColor.substring(1, 3), 16);  
        int startGreen = Integer.parseInt(startColor.substring(3, 5), 16);  
        int startBlue = Integer.parseInt(startColor.substring(5, 7), 16);  
        int endRed = Integer.parseInt(endColor.substring(1, 3), 16);  
        int endGreen = Integer.parseInt(endColor.substring(3, 5), 16);  
        int endBlue = Integer.parseInt(endColor.substring(5, 7), 16);  
        // 初始化顏色的值  
        if (mCurrentRed == -1) {  
            mCurrentRed = startRed;  
        }  
        if (mCurrentGreen == -1) {  
            mCurrentGreen = startGreen;  
        }  
        if (mCurrentBlue == -1) {  
            mCurrentBlue = startBlue;  
        }  
        // 計算初始顏色和結(jié)束顏色之間的差值  
        int redDiff = Math.abs(startRed - endRed);  
        int greenDiff = Math.abs(startGreen - endGreen);  
        int blueDiff = Math.abs(startBlue - endBlue);  
        int colorDiff = redDiff + greenDiff + blueDiff;  
        if (mCurrentRed != endRed) {  
            mCurrentRed = getCurrentColor(startRed, endRed, colorDiff, 0,  
                    fraction);  
        } else if (mCurrentGreen != endGreen) {  
            mCurrentGreen = getCurrentColor(startGreen, endGreen, colorDiff,  
                    redDiff, fraction);  
        } else if (mCurrentBlue != endBlue) {  
            mCurrentBlue = getCurrentColor(startBlue, endBlue, colorDiff,  
                    redDiff + greenDiff, fraction);  
        }  
        // 將計算出的當(dāng)前顏色的值組裝返回  
        String currentColor = "#" + getHexString(mCurrentRed)  
                + getHexString(mCurrentGreen) + getHexString(mCurrentBlue);  
        return currentColor;  
    }  
  
    /** 
     * 根據(jù)fraction值來計算當(dāng)前的顏色。 
     */  
    private int getCurrentColor(int startColor, int endColor, int colorDiff,  
            int offset, float fraction) {  
        int currentColor;  
        if (startColor > endColor) {  
            currentColor = (int) (startColor - (fraction * colorDiff - offset));  
            if (currentColor < endColor) {  
                currentColor = endColor;  
            }  
        } else {  
            currentColor = (int) (startColor + (fraction * colorDiff - offset));  
            if (currentColor > endColor) {  
                currentColor = endColor;  
            }  
        }  
        return currentColor;  
    }  
      
    /** 
     * 將10進(jìn)制顏色值轉(zhuǎn)換成16進(jìn)制。 
     */  
    private String getHexString(int value) {  
        String hexString = Integer.toHexString(value);  
        if (hexString.length() == 1) {  
            hexString = "0" + hexString;  
        }  
        return hexString;  
    }  
  
}  

這大概是我們整個動畫操作當(dāng)中最復(fù)雜的一個類了。沒錯，屬性動畫的高級用法中最有技術(shù)含量的也就是如何編寫出一個合適的TypeEvaluator。好在剛才我們已經(jīng)編寫了一個PointEvaluator，對它的基本工作原理已經(jīng)有了了解，那么這里我們主要學(xué)習(xí)一下ColorEvaluator的邏輯流程吧。

首先在evaluate()方法當(dāng)中獲取到顏色的初始值和結(jié)束值，并通過字符串截取的方式將顏色分為RGB三個部分，并將RGB的值轉(zhuǎn)換成十進(jìn)制數(shù)字，那么每個顏色的取值范圍就是0-255。接下來計算一下初始顏色值到結(jié)束顏色值之間的差值，這個差值很重要，決定著顏色變化的快慢，如果初始顏色值和結(jié)束顏色值很相近，那么顏色變化就會比較緩慢，而如果顏色值相差很大，比如說從黑到白，那么就要經(jīng)歷255*3這個幅度的顏色過度，變化就會非?？臁?/p>

那么控制顏色變化的速度是通過getCurrentColor()這個方法來實現(xiàn)的，這個方法會根據(jù)當(dāng)前的fraction值來計算目前應(yīng)該過度到什么顏色，并且這里會根據(jù)初始和結(jié)束的顏色差值來控制變化速度，最終將計算出的顏色進(jìn)行返回。

最后，由于我們計算出的顏色是十進(jìn)制數(shù)字，這里還需要調(diào)用一下getHexString()方法把它們轉(zhuǎn)換成十六進(jìn)制字符串，再將RGB顏色拼裝起來之后作為最終的結(jié)果返回。

好了，ColorEvaluator寫完之后我們就把最復(fù)雜的工作完成了，剩下的就是一些簡單調(diào)用的問題了，比如說我們想要實現(xiàn)從藍(lán)色到紅色的動畫過度，歷時5秒，就可以這樣寫：

ObjectAnimator anim = ObjectAnimator.ofObject(myAnimView, "color", new ColorEvaluator(),   
    "#0000FF", "#FF0000");  
anim.setDuration(5000);  
anim.start();  

用法非常簡單易懂，相信不需要我再進(jìn)行解釋了。

接下來我們需要將上面一段代碼移到MyAnimView類當(dāng)中，讓它和剛才的Point移動動畫可以結(jié)合到一起播放，這就要借助我們在上篇文章當(dāng)中學(xué)到的組合動畫的技術(shù)了。修改MyAnimView中的代碼，如下所示：

public class MyAnimView extends View {  
  
    ...  
  
    private void startAnimation() {  
        Point startPoint = new Point(RADIUS, RADIUS);  
        Point endPoint = new Point(getWidth() - RADIUS, getHeight() - RADIUS);  
        ValueAnimator anim = ValueAnimator.ofObject(new PointEvaluator(), startPoint, endPoint);  
        anim.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {  
            @Override  
            public void onAnimationUpdate(ValueAnimator animation) {  
                currentPoint = (Point) animation.getAnimatedValue();  
                invalidate();  
            }  
        });  
        ObjectAnimator anim2 = ObjectAnimator.ofObject(this, "color", new ColorEvaluator(),   
                "#0000FF", "#FF0000");  
        AnimatorSet animSet = new AnimatorSet();  
        animSet.play(anim).with(anim2);  
        animSet.setDuration(5000);  
        animSet.start();  
    }  
  
}  

可以看到，我們并沒有改動太多的代碼，重點只是修改了startAnimation()方法中的部分內(nèi)容。這里先是將顏色過度的代碼邏輯移動到了startAnimation()方法當(dāng)中，注意由于這段代碼本身就是在MyAnimView當(dāng)中執(zhí)行的，因此ObjectAnimator.ofObject()的第一個參數(shù)直接傳this就可以了。接著我們又創(chuàng)建了一個AnimatorSet，并把兩個動畫設(shè)置成同時播放，動畫時長為五秒，最后啟動動畫?，F(xiàn)在重新運行一下代碼，效果如下圖所示：

OK，位置動畫和顏色動畫非常融洽的結(jié)合到一起了，看上去效果還是相當(dāng)不錯的，這樣我們就把ObjectAnimator的高級用法也掌握了。