3. Property Animation

屬性動畫，這個是在Android 3.0中才引進的，它更改的是對象的實際屬性，在View Animation（Tween Animation）中，其改變的是View的繪制效果，真正的View的屬性保持不變，比如無論你在對話中如何縮放Button的大小，Button的有效點擊區域還是沒有應用動畫時的區域，其位置與大小都不變。而在Property Animation中，改變的是對象的實際屬性，如Button的縮放，Button的位置與大小屬性值都改變了。而且Property Animation不止可以應用於View，還可以應用於任何對象。Property Animation只是表示一個值在一段時間內的改變，當值改變時要做什麼事情完全是你自己決定的。

在Property Animation中，可以對動畫應用以下屬性：

• Duration：動畫的持續時間
• TimeInterpolation：屬性值的計算方式，如先快後慢
• TypeEvaluator：根據屬性的開始、結束值與TimeInterpolation計算出的因子計算出當前時間的屬性值
• Repeat Count and behavoir：重復次數與方式，如播放3次、5次、無限循環，可以此動畫一直重復，或播放完時再反向播放
• Animation sets：動畫集合，即可以同時對一個對象應用幾個動畫，這些動畫可以同時播放也可以對不同動畫設置不同開始偏移
• Frame refreash delay：多少時間刷新一次，即每隔多少時間計算一次屬性值，默認為10ms，最終刷新時間還受系統進程調度與硬件的影響

  
  

  Interpolator

  
  

  首先要了解為什麼需要插值器，因為在補間動畫中，我們一般只定義關鍵幀（首幀或尾幀），然後由系統自動生成中間幀，生成中間幀的這個過程可以成為“插值”。插值器定義了動畫變化的速率，提供不同的函數定義變化值相對於時間的變化規則，可以定義各種各樣的非線性變化函數，比如加速、減速等。下面是幾種常見的插值器：

  Interpolator對象 資源ID 功能作用 AccelerateDecelerateInterpolator @android:anim/accelerate_decelerate_interpolator 先加速再減速 AccelerateInterpolator @android:anim/accelerate_interpolator 加速 AnticipateInterpolator @android:anim/anticipate_interpolator 先回退一小步然後加速前進 AnticipateOvershootInterpolator @android:anim/anticipate_overshoot_interpolator 在上一個基礎上超出終點一小步再回到終點 BounceInterpolator @android:anim/bounce_interpolator 最後階段彈球效果 CycleInterpolator @android:anim/cycle_interpolator 周期運動 DecelerateInterpolator @android:anim/decelerate_interpolator 減速 LinearInterpolator @android:anim/linear_interpolator 勻速 OvershootInterpolator @android:anim/overshoot_interpolator 快速到達終點並超出一小步最後回到終點
  
  

  如果只簡單地引用這些插值器還不能滿足需要的話，我們要考慮一下個性化插值器。我們可以創建一個插值器資源修改插值器的屬性，比如修改AnticipateInterpolator的加速速率，調整CycleInterpolator的循環次數等。為了完成這種需求，我們需要創建XML資源文件，然後將其放於/res/anim下，然後再動畫元素中引用即可。我們先來看一下幾種常見的插值器可調整的屬性：

   無
   android:factor 浮點值，加速速率，默認為1
   android:tension 浮點值，起始點後退的張力、拉力數，默認為2
   android:tension 同上 android:extraTension 浮點值，拉力的倍數，默認為1.5（2  * 1.5）
   無
   android:cycles 整數值，循環的個數，默認為1
   android:factor 浮點值，減速的速率，默認為1
   無
   浮點值，超出終點後的張力、拉力，默認為2

  
  
  

  下面我們就拿最後一個插值器來舉例：

  上面的代碼中，我們把張力改為7.0，然後將此文件命名為my_overshoot_interpolator.xml，放置於/res/anim下，我們就可以引用到自定義的插值器了：
  

  
  

  AccelerateDecelerateInterpolator

  /**
   * An interpolator where the rate of change starts and ends slowly but
   * accelerates through the middle.
   * 
   */
  public class AccelerateDecelerateInterpolator implements Interpolator {
      public AccelerateDecelerateInterpolator() {
      }
      
      @SuppressWarnings({"UnusedDeclaration"})
      public AccelerateDecelerateInterpolator(Context context, AttributeSet attrs) {
      }
      
      public float getInterpolation(float input) {
          return (float)(Math.cos((input + 1) * Math.PI) / 2.0f) + 0.5f;
      }
  }

  
  
  

  

  <喎?/kf/ware/vc/" target="_blank" class="keylink">vcD4KPGgyPgpBY2NlbGVyYXRlSW50ZXJwb2xhdG9yPC9oMj4KPHByZSBjbGFzcz0="brush:java;">/** * An interpolator where the rate of change starts out slowly and * and then accelerates. * */ public class AccelerateInterpolator implements Interpolator { private final float mFactor; private final double mDoubleFactor; public AccelerateInterpolator() { mFactor = 1.0f; mDoubleFactor = 2.0; } /** * Constructor * * @param factor Degree to which the animation should be eased. Seting * factor to 1.0f produces a y=x^2 parabola. Increasing factor above * 1.0f exaggerates the ease-in effect (i.e., it starts even * slower and ends evens faster) */ public AccelerateInterpolator(float factor) { mFactor = factor; mDoubleFactor = 2 * mFactor; } public AccelerateInterpolator(Context context, AttributeSet attrs) { TypedArray a = context.obtainStyledAttributes(attrs, com.android.internal.R.styleable.AccelerateInterpolator); mFactor = a.getFloat(com.android.internal.R.styleable.AccelerateInterpolator_factor, 1.0f); mDoubleFactor = 2 * mFactor; a.recycle(); } public float getInterpolation(float input) { if (mFactor == 1.0f) { return input * input; } else { return (float)Math.pow(input, mDoubleFactor); } } }
  
  

  

  AnticipateInterpolator

  /**
   * An interpolator where the change starts backward then flings forward.
   */
  public class AnticipateInterpolator implements Interpolator {
      private final float mTension;
  
      public AnticipateInterpolator() {
          mTension = 2.0f;
      }
  
      /**
       * @param tension Amount of anticipation. When tension equals 0.0f, there is
       *                no anticipation and the interpolator becomes a simple
       *                acceleration interpolator.
       */
      public AnticipateInterpolator(float tension) {
          mTension = tension;
      }
  
      public AnticipateInterpolator(Context context, AttributeSet attrs) {
          TypedArray a = context.obtainStyledAttributes(attrs,
                  com.android.internal.R.styleable.AnticipateInterpolator);
  
          mTension =
                  a.getFloat(com.android.internal.R.styleable.AnticipateInterpolator_tension, 2.0f);
  
          a.recycle();
      }
  
      public float getInterpolation(float t) {
          // a(t) = t * t * ((tension + 1) * t - tension)
          return t * t * ((mTension + 1) * t - mTension);
      }
  }

  
  
  

  

  AnticipateOvershootInterpolator

  /**
   * An interpolator where the change starts backward then flings forward and overshoots
   * the target value and finally goes back to the final value.
   */
  public class AnticipateOvershootInterpolator implements Interpolator {
      private final float mTension;
  
      public AnticipateOvershootInterpolator() {
          mTension = 2.0f * 1.5f;
      }
  
      /**
       * @param tension Amount of anticipation/overshoot. When tension equals 0.0f,
       *                there is no anticipation/overshoot and the interpolator becomes
       *                a simple acceleration/deceleration interpolator.
       */
      public AnticipateOvershootInterpolator(float tension) {
          mTension = tension * 1.5f;
      }
  
      /**
       * @param tension Amount of anticipation/overshoot. When tension equals 0.0f,
       *                there is no anticipation/overshoot and the interpolator becomes
       *                a simple acceleration/deceleration interpolator.
       * @param extraTension Amount by which to multiply the tension. For instance,
       *                     to get the same overshoot as an OvershootInterpolator with
       *                     a tension of 2.0f, you would use an extraTension of 1.5f.
       */
      public AnticipateOvershootInterpolator(float tension, float extraTension) {
          mTension = tension * extraTension;
      }
  
      public AnticipateOvershootInterpolator(Context context, AttributeSet attrs) {
          TypedArray a = context.obtainStyledAttributes(attrs, AnticipateOvershootInterpolator);
  
          mTension = a.getFloat(AnticipateOvershootInterpolator_tension, 2.0f) *
                  a.getFloat(AnticipateOvershootInterpolator_extraTension, 1.5f);
  
          a.recycle();
      }
  
      private static float a(float t, float s) {
          return t * t * ((s + 1) * t - s);
      }
  
      private static float o(float t, float s) {
          return t * t * ((s + 1) * t + s);
      }
  
      public float getInterpolation(float t) {
          // a(t, s) = t * t * ((s + 1) * t - s)
          // o(t, s) = t * t * ((s + 1) * t + s)
          // f(t) = 0.5 * a(t * 2, tension * extraTension), when t < 0.5
          // f(t) = 0.5 * (o(t * 2 - 2, tension * extraTension) + 2), when t <= 1.0
          if (t < 0.5f) return 0.5f * a(t * 2.0f, mTension);
          else return 0.5f * (o(t * 2.0f - 2.0f, mTension) + 2.0f);
      }
  }

  
  
  

  

  BounceInterpolator

  /**
   * An interpolator where the change bounces at the end.
   */
  public class BounceInterpolator implements Interpolator {
      public BounceInterpolator() {
      }
  
      @SuppressWarnings({"UnusedDeclaration"})
      public BounceInterpolator(Context context, AttributeSet attrs) {
      }
  
      private static float bounce(float t) {
          return t * t * 8.0f;
      }
  
      public float getInterpolation(float t) {
          // _b(t) = t * t * 8
          // bs(t) = _b(t) for t < 0.3535
          // bs(t) = _b(t - 0.54719) + 0.7 for t < 0.7408
          // bs(t) = _b(t - 0.8526) + 0.9 for t < 0.9644
          // bs(t) = _b(t - 1.0435) + 0.95 for t <= 1.0
          // b(t) = bs(t * 1.1226)
          t *= 1.1226f;
          if (t < 0.3535f) return bounce(t);
          else if (t < 0.7408f) return bounce(t - 0.54719f) + 0.7f;
          else if (t < 0.9644f) return bounce(t - 0.8526f) + 0.9f;
          else return bounce(t - 1.0435f) + 0.95f;
      }
  }

  
  
  

  

  CycleInterpolator

  /**
   * Repeats the animation for a specified number of cycles. The
   * rate of change follows a sinusoidal pattern.
   *
   */
  public class CycleInterpolator implements Interpolator {
      public CycleInterpolator(float cycles) {
          mCycles = cycles;
      }
      
      public CycleInterpolator(Context context, AttributeSet attrs) {
          TypedArray a =
              context.obtainStyledAttributes(attrs, com.android.internal.R.styleable.CycleInterpolator);
          
          mCycles = a.getFloat(com.android.internal.R.styleable.CycleInterpolator_cycles, 1.0f);
          
          a.recycle();
      }
      
      public float getInterpolation(float input) {
          return (float)(Math.sin(2 * mCycles * Math.PI * input));
      }
      
      private float mCycles;
  }

  
  
  

  　　參數為2時的曲線：

  

  DecelerateInterpolator

  
  

  /**
   * An interpolator where the rate of change starts out quickly and 
   * and then decelerates.
   *
   */
  public class DecelerateInterpolator implements Interpolator {
      public DecelerateInterpolator() {
      }
  
      /**
       * Constructor
       * 
       * @param factor Degree to which the animation should be eased. Setting factor to 1.0f produces
       *        an upside-down y=x^2 parabola. Increasing factor above 1.0f makes exaggerates the
       *        ease-out effect (i.e., it starts even faster and ends evens slower)
       */
      public DecelerateInterpolator(float factor) {
          mFactor = factor;
      }
      
      public DecelerateInterpolator(Context context, AttributeSet attrs) {
          TypedArray a =
              context.obtainStyledAttributes(attrs, com.android.internal.R.styleable.DecelerateInterpolator);
          
          mFactor = a.getFloat(com.android.internal.R.styleable.DecelerateInterpolator_factor, 1.0f);
          
          a.recycle();
      }
      
      public float getInterpolation(float input) {
          float result;
          if (mFactor == 1.0f) {
              result = (float)(1.0f - (1.0f - input) * (1.0f - input));
          } else {
              result = (float)(1.0f - Math.pow((1.0f - input), 2 * mFactor));
          }
          return result;
      }
      
      private float mFactor = 1.0f;
  }

  
  

  

  LinearInterpolator

  /**
   * An interpolator where the rate of change is constant
   *
   */
  public class LinearInterpolator implements Interpolator {
  
      public LinearInterpolator() {
      }
      
      public LinearInterpolator(Context context, AttributeSet attrs) {
      }
      
      public float getInterpolation(float input) {
          return input;
      }
  }

  
  
  

  

  OvershootInterpolator

  /**
   * An interpolator where the change flings forward and overshoots the last value
   * then comes back.
   */
  public class OvershootInterpolator implements Interpolator {
      private final float mTension;
  
      public OvershootInterpolator() {
          mTension = 2.0f;
      }
  
      /**
       * @param tension Amount of overshoot. When tension equals 0.0f, there is
       *                no overshoot and the interpolator becomes a simple
       *                deceleration interpolator.
       */
      public OvershootInterpolator(float tension) {
          mTension = tension;
      }
  
      public OvershootInterpolator(Context context, AttributeSet attrs) {
          TypedArray a = context.obtainStyledAttributes(attrs,
                  com.android.internal.R.styleable.OvershootInterpolator);
  
          mTension =
                  a.getFloat(com.android.internal.R.styleable.OvershootInterpolator_tension, 2.0f);
  
          a.recycle();
      }
  
      public float getInterpolation(float t) {
          // _o(t) = t * t * ((tension + 1) * t + tension)
          // o(t) = _o(t - 1) + 1
          t -= 1.0f;
          return t * t * ((mTension + 1) * t + mTension) + 1.0f;
      }
  }

  
  
  

  

  
  
  
• 要在代碼中調用Imageview的setBackgroundResource方法，如果直接在XML布局文件中設置其src屬性當觸發動畫時會FC。
• 在動畫start()之前要先stop()，不然在第一次動畫之後會停在最後一幀，這樣動畫就只會觸發一次。
• 最後一點是SDK中提到的，不要在onCreate中調用start，因為AnimationDrawable還沒有完全跟Window相關聯，如果想要界面顯示時就開始動畫的話，可以在onWindowFoucsChanged()中調用start()。