content: /**
   * Copyright 2014 Zhenguo Jin (jinzhenguo1990@gmail.com)
   * <p/>
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   * <p/>
   * http://www.apache.org/licenses/LICENSE-2.0
   * <p/>
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  package com.rsen.github.androidutils;
  
  import android.view.animation.AlphaAnimation;
  import android.view.animation.Animation;
  import android.view.animation.Animation.AnimationListener;
  import android.view.animation.RotateAnimation;
  import android.view.animation.ScaleAnimation;
  
  /**
   * 动画工具类
   *
   * @author zhenguo
   */
  public final class AnimationUtils {
  
      /**
       * Don't let anyone instantiate this class.
       */
      private AnimationUtils() {
          throw new Error("Do not need instantiate!");
      }
  
      /**
       * 默认动画持续时间
       */
      public static final long DEFAULT_ANIMATION_DURATION = 400;
  
      /**
       * 获取一个旋转动画
       *
       * @param fromDegrees       开始角度
       * @param toDegrees         结束角度
       * @param pivotXType        旋转中心点X轴坐标相对类型
       * @param pivotXValue       旋转中心点X轴坐标
       * @param pivotYType        旋转中心点Y轴坐标相对类型
       * @param pivotYValue       旋转中心点Y轴坐标
       * @param durationMillis    持续时间
       * @param animationListener 动画监听器
       * @return 一个旋转动画
       */
      public static RotateAnimation getRotateAnimation(float fromDegrees, float toDegrees, int pivotXType, float pivotXValue, int pivotYType, float pivotYValue, long durationMillis, AnimationListener animationListener) {
          RotateAnimation rotateAnimation = new RotateAnimation(fromDegrees, toDegrees, pivotXType, pivotXValue, pivotYType, pivotYValue);
          rotateAnimation.setDuration(durationMillis);
          if (animationListener != null) {
              rotateAnimation.setAnimationListener(animationListener);
          }
          return rotateAnimation;
      }
  
      /**
       * 获取一个根据视图自身中心点旋转的动画
       *
       * @param durationMillis    动画持续时间
       * @param animationListener 动画监听器
       * @return 一个根据中心点旋转的动画
       */
      public static RotateAnimation getRotateAnimationByCenter(long durationMillis, AnimationListener animationListener) {
          return getRotateAnimation(0f, 359f, Animation.RELATIVE_TO_SELF, 0.5f, Animation.RELATIVE_TO_SELF, 0.5f, durationMillis, animationListener);
      }
  
      /**
       * 获取一个根据中心点旋转的动画
       *
       * @param duration 动画持续时间
       * @return 一个根据中心点旋转的动画
       */
      public static RotateAnimation getRotateAnimationByCenter(long duration) {
          return getRotateAnimationByCenter(duration, null);
      }
  
      /**
       * 获取一个根据视图自身中心点旋转的动画
       *
       * @param animationListener 动画监听器
       * @return 一个根据中心点旋转的动画
       */
      public static RotateAnimation getRotateAnimationByCenter(AnimationListener animationListener) {
          return getRotateAnimationByCenter(DEFAULT_ANIMATION_DURATION, animationListener);
      }
  
      /**
       * 获取一个根据中心点旋转的动画
       *
       * @return 一个根据中心点旋转的动画，默认持续时间为DEFAULT_ANIMATION_DURATION
       */
      public static RotateAnimation getRotateAnimationByCenter() {
          return getRotateAnimationByCenter(DEFAULT_ANIMATION_DURATION, null);
      }
  
      /**
       * 获取一个透明度渐变动画
       *
       * @param fromAlpha         开始时的透明度
       * @param toAlpha           结束时的透明度都
       * @param durationMillis    持续时间
       * @param animationListener 动画监听器
       * @return 一个透明度渐变动画
       */
      public static AlphaAnimation getAlphaAnimation(float fromAlpha, float toAlpha, long durationMillis, AnimationListener animationListener) {
          AlphaAnimation alphaAnimation = new AlphaAnimation(fromAlpha, toAlpha);
          alphaAnimation.setDuration(durationMillis);
          if (animationListener != null) {
              alphaAnimation.setAnimationListener(animationListener);
          }
          return alphaAnimation;
      }
  
      /**
       * 获取一个透明度渐变动画
       *
       * @param fromAlpha      开始时的透明度
       * @param toAlpha        结束时的透明度都
       * @param durationMillis 持续时间
       * @return 一个透明度渐变动画
       */
      public static AlphaAnimation getAlphaAnimation(float fromAlpha, float toAlpha, long durationMillis) {
          return getAlphaAnimation(fromAlpha, toAlpha, durationMillis, null);
      }
  
      /**
       * 获取一个透明度渐变动画
       *
       * @param fromAlpha         开始时的透明度
       * @param toAlpha           结束时的透明度都
       * @param animationListener 动画监听器
       * @return 一个透明度渐变动画，默认持续时间为DEFAULT_ANIMATION_DURATION
       */
      public static AlphaAnimation getAlphaAnimation(float fromAlpha, float toAlpha, AnimationListener animationListener) {
          return getAlphaAnimation(fromAlpha, toAlpha, DEFAULT_ANIMATION_DURATION, animationListener);
      }
  
      /**
       * 获取一个透明度渐变动画
       *
       * @param fromAlpha 开始时的透明度
       * @param toAlpha   结束时的透明度都
       * @return 一个透明度渐变动画，默认持续时间为DEFAULT_ANIMATION_DURATION
       */
      public static AlphaAnimation getAlphaAnimation(float fromAlpha, float toAlpha) {
          return getAlphaAnimation(fromAlpha, toAlpha, DEFAULT_ANIMATION_DURATION, null);
      }
  
      /**
       * 获取一个由完全显示变为不可见的透明度渐变动画
       *
       * @param durationMillis    持续时间
       * @param animationListener 动画监听器
       * @return 一个由完全显示变为不可见的透明度渐变动画
       */
      public static AlphaAnimation getHiddenAlphaAnimation(long durationMillis, AnimationListener animationListener) {
          return getAlphaAnimation(1.0f, 0.0f, durationMillis, animationListener);
      }
  
      /**
       * 获取一个由完全显示变为不可见的透明度渐变动画
       *
       * @param durationMillis 持续时间
       * @return 一个由完全显示变为不可见的透明度渐变动画
       */
      public static AlphaAnimation getHiddenAlphaAnimation(long durationMillis) {
          return getHiddenAlphaAnimation(durationMillis, null);
      }
  
      /**
       * 获取一个由完全显示变为不可见的透明度渐变动画
       *
       * @param animationListener 动画监听器
       * @return 一个由完全显示变为不可见的透明度渐变动画，默认持续时间为DEFAULT_ANIMATION_DURATION
       */
      public static AlphaAnimation getHiddenAlphaAnimation(AnimationListener animationListener) {
          return getHiddenAlphaAnimation(DEFAULT_ANIMATION_DURATION, animationListener);
      }
  
      /**
       * 获取一个由完全显示变为不可见的透明度渐变动画
       *
       * @return 一个由完全显示变为不可见的透明度渐变动画，默认持续时间为DEFAULT_ANIMATION_DURATION
       */
      public static AlphaAnimation getHiddenAlphaAnimation() {
          return getHiddenAlphaAnimation(DEFAULT_ANIMATION_DURATION, null);
      }
  
      /**
       * 获取一个由不可见变为完全显示的透明度渐变动画
       *
       * @param durationMillis    持续时间
       * @param animationListener 动画监听器
       * @return 一个由不可见变为完全显示的透明度渐变动画
       */
      public static AlphaAnimation getShowAlphaAnimation(long durationMillis, AnimationListener animationListener) {
          return getAlphaAnimation(0.0f, 1.0f, durationMillis, animationListener);
      }
  
      /**
       * 获取一个由不可见变为完全显示的透明度渐变动画
       *
       * @param durationMillis 持续时间
       * @return 一个由不可见变为完全显示的透明度渐变动画
       */
      public static AlphaAnimation getShowAlphaAnimation(long durationMillis) {
          return getAlphaAnimation(0.0f, 1.0f, durationMillis, null);
      }
  
      /**
       * 获取一个由不可见变为完全显示的透明度渐变动画
       *
       * @param animationListener 动画监听器
       * @return 一个由不可见变为完全显示的透明度渐变动画，默认持续时间为DEFAULT_ANIMATION_DURATION
       */
      public static AlphaAnimation getShowAlphaAnimation(AnimationListener animationListener) {
          return getAlphaAnimation(0.0f, 1.0f, DEFAULT_ANIMATION_DURATION, animationListener);
      }
  
      /**
       * 获取一个由不可见变为完全显示的透明度渐变动画
       *
       * @return 一个由不可见变为完全显示的透明度渐变动画，默认持续时间为DEFAULT_ANIMATION_DURATION
       */
      public static AlphaAnimation getShowAlphaAnimation() {
          return getAlphaAnimation(0.0f, 1.0f, DEFAULT_ANIMATION_DURATION, null);
      }
  
      /**
       * 获取一个缩小动画
       *
       * @param durationMillis
       * @param animationListener
       * @return
       */
      public static ScaleAnimation getLessenScaleAnimation(long durationMillis, AnimationListener animationListener) {
          ScaleAnimation scaleAnimation = new ScaleAnimation(1.0f, 0.0f, 1.0f, 0.0f, ScaleAnimation.RELATIVE_TO_SELF, ScaleAnimation.RELATIVE_TO_SELF);
          scaleAnimation.setDuration(durationMillis);
          scaleAnimation.setAnimationListener(animationListener);
          return scaleAnimation;
      }
  
      /**
       * 获取一个缩小动画
       *
       * @param durationMillis
       * @return
       */
      public static ScaleAnimation getLessenScaleAnimation(long durationMillis) {
          return getLessenScaleAnimation(durationMillis, null);
      }
  
      /**
       * 获取一个缩小动画
       *
       * @param animationListener
       * @return
       */
      public static ScaleAnimation getLessenScaleAnimation(AnimationListener animationListener) {
          return getLessenScaleAnimation(DEFAULT_ANIMATION_DURATION, animationListener);
      }
  
      /**
       * 获取一个放大动画
       *
       * @param durationMillis
       * @param animationListener
       * @return
       */
      public static ScaleAnimation getAmplificationAnimation(long durationMillis, AnimationListener animationListener) {
          ScaleAnimation scaleAnimation = new ScaleAnimation(0.0f, 1.0f, 0.0f, 1.0f, ScaleAnimation.RELATIVE_TO_SELF, ScaleAnimation.RELATIVE_TO_SELF);
          scaleAnimation.setDuration(durationMillis);
          scaleAnimation.setAnimationListener(animationListener);
          return scaleAnimation;
      }
  
      /**
       * 获取一个放大动画
       *
       * @param durationMillis
       * @return
       */
      public static ScaleAnimation getAmplificationAnimation(long durationMillis) {
          return getAmplificationAnimation(durationMillis, null);
      }
  
      /**
       * 获取一个放大动画
       *
       * @param animationListener
       * @return
       */
      public static ScaleAnimation getAmplificationAnimation(AnimationListener animationListener) {
          return getAmplificationAnimation(DEFAULT_ANIMATION_DURATION, animationListener);
      }
  
  }
  