Android 动画详解

这次主要就介绍android动画，android动画目前分为三种形式，Tween Animation 这个只能应用于view对象上面的，Drawable Animation这个是帧动画，就是类似我们有一些列的图片依次播放图片时出现的动画，Property Animation 这个是属性动画，这也是在android3.0之后引进的动画，在手机的版本上是android４.0就可以使用这个动画，下面我们主要就是针对这三种情况进行介绍。

 

Tween Animation

这个动画在Property Animation之前使用最多的，当然在android4.0之后也是有很多人使用这个动画来弄一些简单的动画效果，Tween Animation主要是包括四种动画实现效果：

 

• AlphaAniamtion:渐变效果，这个是一个透明度的动画效果

AlphaAnimation(float fromAlpha,float toAlpha)

 这个就是AlphaAnimation的构造函数，fromAlpha表示的是动画初始时的透明度，toAlpha表示的是动画结束时的透明度，这个取值范围是０～1，0表示的是完全透明，１表示的是完全不透明

 

• ScaleAnimation:图片进行放大缩小的动画效果，

ScaleAnimation(float fromX, float toX, float fromY,float toY, int pivotXType, float pivotXValue, int pivotYType, float pivotYValue)

上面就是这个Scale参数的情况，这个参数是最多的，fromX：起始X坐标上的伸缩尺寸,toX：结束X坐标上的伸缩尺寸,fromY：起始Y坐标上的伸缩尺寸,toY：结束Y坐标上的伸缩尺寸,关于这个伸缩尺寸，０表示的就是看不见，１表示原始大小，依此类推，１.5表示的就是1.5倍

pivotXType和pivotYType分别表示在X和Y轴上伸缩模式。这里有三个值：

Animation.ABSOLUTE：这个表示的是绝对坐标

Animation.RELATIVE_TO_SELF：相对于自己的坐标

Animation.RELATIVE_TO_PARENT：相对于父控件

上面这些说的都是这个动画效果相对于哪一个点来进行变化的，Animation.RELATIVE_TO_SELF这个就相对于自己的坐标，就是说这个坐标原始坐标是在你设置view的左上角，Animation.RELATIVE_TO_PARENT相对于父控件的坐标，这个大多数指的就是手机上的坐标原点。Animation.ABSOLUTE绝对坐标说的就是具体相对哪个一个点，比如(100,200)，就是表示相对坐标点在(100,200)这个点来进行动画。

pivotXValue和pivotYValue值就是相对上面的值设置的，表示的是相对于哪一个点来进行放大缩小的动画，对于Animation.RELATIVE_TO_SELF和Animation.RELATIVE_TO_PARENT

(0,0)表示的是原点，（0.5f,0.5f）表示的中间点这个对于Animation.RELATIVE_TO_SELF相对于view控件的中间点，Animation.RELATIVE_TO_PARENT就是值该view上父控件的中间点，(1,1)表示的就是右下角的坐标。这个我们可以多多试试就知道效果了。

一般情况下使用是Animation.RELATIVE_TO_SELF，选择点是(0.5f,0.5f)就是该view的中间点，这样图片变化看起来不会产生很奇怪的感觉。

 

• TranslateAnimation:view在水平方向和垂直方向进行移动动画效果

TranslateAnimation(fromXDelta, toXDelta, fromYDelta, toYDelta)

fromXDelta和fromYDelta分别表示在X和Y轴上面的起始坐标，（0，0）这个表示的就是当前view的坐标，toXDelta和toYDelta分别表示最终目标，如果只是X轴移动或者Y轴移动，那么可以把对应不移动的坐标设置为０。

 

• RotateAnimation：旋转动画效果

RotateAnimation(fromDegrees, toDegrees, pivotXType, pivotXValue, pivotYType, pivotYValue)

fromDegrees和toDegrees分别表示的起始角度和结束角度，比如（０,4５）这个就是表示从默认状态旋转到４５度的意思。剩下的参数上面已经介绍过来，比如下面的代码：

RotateAnimation rotate=new RotateAnimation(0, 50, Animation.RELATIVE_TO_SELF, 0.5f, Animation.RELATIVE_TO_SELF, 0.5f);

表示就是从默认状态旋转到５０度，旋转的中心点就是这个view的中心点(Animation.RELATIVE_TO_SELF表示的以自身为参考点，0.5f表示就是一般)

上面介绍就是这个Tween Animation动画效果，分别是透明度的变化，放大缩小，移动以及旋转动画效果，这些动画除了上面的构造函数之外当然还有一些公共的其它方法，下面就介绍一下：

setDuration(long durationMillis)

这个表示的是设置动画的显示时间，就是这个动画从初始状态到结束状态所需要的时间，durationMillis参数为动画显示时间的长短，单位是毫秒。

setStartOffset(long startOffset)

这个表示的是动画的开始时间，startOffset表示就是动画的开始时间，单位毫秒（有时候我们在startAnimation之后可能不希望立即取执行这个动画，需要等待一会再进行动画就可以使用这个

setFillAfter(boolean fillAfter)

这个表示的动画结束之后是否保留结束的位置，这个值默认是flase表示动画结束之后不保留动画的位置，就是说在我们进行动画效果结束之后又会自动恢复到原始的状态，true表示就是保留动画结束时的状态，这个值一般都是要设置为true的

startAnimation(Animation animation)

这个是在view对象上使用的，表示开始进行动画，参数就是我们上面说的那四种(注意上面的四种类型都是继承于Animation的)，比如我现在有一个ImageView对象image,那么我现在要开始动画时就是用imageView.startAnimation(rotateAnimation);就可以进行动画了，

setInterpolator(Interpolator i)

这个表示的设置动画的变化速度，这里android提供很多类型的Interpolator类型的变化器

１。setInterpolator(new AccelerateInterpolator(float factor)：这个AccelerateInterpolator表示的是加速，factor参数可以设置为加速的倍数，数值越大动画的速度越快，当然也可以是默认的new AccelerateInterpolator（）默认这个参数为１。我们来看一下源码：

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

上面那个就是AccelerateInterpolator的源码，这个源码中有两个构造函数一个带参数一个不带参数的，从上面代码中getInterpolation这个方法是最重要的，那么跟踪一下这个方法调用是在Animation.java类中的getTransformation()方法

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

上面就是getTransformation()方法，在这个方法中也看到之前设置的getStartOffset()以及mDuration等等，在下面发现这么一句话

final float interpolatedTime = mInterpolator.getInterpolation(normalizedTime);mInterpolator对象创建也是在这个类里面

    public void setInterpolator(Interpolator i) {
        mInterpolator = i;
    }

看上面就是我们代码中设置的，那么来看看这个getInterpolation里面参数的值，从上面源码中知道mFillEnabled和mCycleFlip默认值都是flase,一般情况下我们都不会去设置这两个值都是取默认值的，if (mFillEnabled) normalizedTime = Math.max(Math.min(normalizedTime, 1.0f), 0.0f);这个设置了normalizedTime的值，就是下面要用做getInterpolation参数值，从上面的代码中可以发现normalizedTime这个值是不小于０的，Math.max(Math.min(normalizedTime, 1.0f), 0.0f)表示取值范围就是０～１，也就是手这个getInterpolation（float input）这个input参数的变化就是在指定的动画事件内从０到１递增变化。

我们来看看Interpolator这个类

package android.view.animation;

import android.animation.TimeInterpolator;

/**
 * An interpolator defines the rate of change of an animation. This allows
 * the basic animation effects (alpha, scale, translate, rotate) to be 
 * accelerated, decelerated, repeated, etc.
 */
public interface Interpolator extends TimeInterpolator {
    // A new interface, TimeInterpolator, was introduced for the new android.animation
    // package. This older Interpolator interface extends TimeInterpolator so that users of
    // the new Animator-based animations can use either the old Interpolator implementations or
    // new classes that implement TimeInterpolator directly.
}

再看这个TimeInterpolator类

/*
 * Copyright (C) 2010 The Android Open Source Project
 *
 * 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
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * 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 android.animation;

/**
 * A time interpolator defines the rate of change of an animation. This allows animations
 * to have non-linear motion, such as acceleration and deceleration.
 */
public interface TimeInterpolator {

    /**
     * Maps a value representing the elapsed fraction of an animation to a value that represents
     * the interpolated fraction. This interpolated value is then multiplied by the change in
     * value of an animation to derive the animated value at the current elapsed animation time.
     *
     * @param input A value between 0 and 1.0 indicating our current point
     *        in the animation where 0 represents the start and 1.0 represents
     *        the end
     * @return The interpolation value. This value can be more than 1.0 for
     *         interpolators which overshoot their targets, or less than 0 for
     *         interpolators that undershoot their targets.
     */
    float getInterpolation(float input);
}

从这段代码中我们得出结论就是所有的变化器都是继承于Interpolator接口，而且都实现了float getInterpolation(float input);这个方法，那么我们就要弄清楚这个getTransformation()方法在哪里调用，我们说过StartAnimation是view对象调用那么我们在View.java里面

    public void startAnimation(Animation animation) {
        animation.setStartTime(Animation.START_ON_FIRST_FRAME);
        setAnimation(animation);
        invalidateParentCaches();
        invalidate(true);
    }

这段代码中最后一句就是更新，看一下

  /**
     * This method is called by ViewGroup.drawChild() to have each child view draw itself.
     * This draw() method is an implementation detail and is not intended to be overridden or
     * to be called from anywhere else other than ViewGroup.drawChild().
     */
    boolean draw(Canvas canvas, ViewGroup parent, long drawingTime) {
        boolean useDisplayListProperties = mAttachInfo != null && mAttachInfo.mHardwareAccelerated;
        boolean more = false;
        final boolean childHasIdentityMatrix = hasIdentityMatrix();
        final int flags = parent.mGroupFlags;

        if ((flags & ViewGroup.FLAG_CLEAR_TRANSFORMATION) == ViewGroup.FLAG_CLEAR_TRANSFORMATION) {
            parent.getChildTransformation().clear();
            parent.mGroupFlags &= ~ViewGroup.FLAG_CLEAR_TRANSFORMATION;
        }

        Transformation transformToApply = null;
        boolean concatMatrix = false;

        boolean scalingRequired = false;
        boolean caching;
        int layerType = getLayerType();

        final boolean hardwareAccelerated = canvas.isHardwareAccelerated();
        if ((flags & ViewGroup.FLAG_CHILDREN_DRAWN_WITH_CACHE) != 0 ||
                (flags & ViewGroup.FLAG_ALWAYS_DRAWN_WITH_CACHE) != 0) {
            caching = true;
            // Auto-scaled apps are not hw-accelerated, no need to set scaling flag on DisplayList
            if (mAttachInfo != null) scalingRequired = mAttachInfo.mScalingRequired;
        } else {
            caching = (layerType != LAYER_TYPE_NONE) || hardwareAccelerated;
        }

        final Animation a = getAnimation();
        if (a != null) {
            more = drawAnimation(parent, drawingTime, a, scalingRequired);
            concatMatrix = a.willChangeTransformationMatrix();
            if (concatMatrix) {
                mPrivateFlags3 |= PFLAG3_VIEW_IS_ANIMATING_TRANSFORM;
            }
            transformToApply = parent.getChildTransformation();
        } else {
　　　　　　。。。。。。。。。。。。。。。。。。。。。。。

上面这段代码中有这么一句话 more = drawAnimation(parent, drawingTime, a, scalingRequired)，这个函数就是

    private boolean drawAnimation(ViewGroup parent, long drawingTime,
            Animation a, boolean scalingRequired) {
        Transformation invalidationTransform;
        final int flags = parent.mGroupFlags;
        final boolean initialized = a.isInitialized();
        if (!initialized) {
            a.initialize(mRight - mLeft, mBottom - mTop, parent.getWidth(), parent.getHeight());
            a.initializeInvalidateRegion(0, 0, mRight - mLeft, mBottom - mTop);
            if (mAttachInfo != null) a.setListenerHandler(mAttachInfo.mHandler);
            onAnimationStart();
        }

        final Transformation t = parent.getChildTransformation();
        boolean more = a.getTransformation(drawingTime, t, 1f);
。。。。。。。。。。。。。。。。。。。。。。。。。

 

看到上面的drawAnimation方法中就有a.getTransformation(drawingTime, t, 1f);这个方法，我们也就明白了这个getTransformation()方法是在startAnimation()之后调用的。

２。setInterpolator(new AccelerateDecelerateInterpolator())：这个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;
    }
}

３。setInterpolator(new DecelerateInterpolator(float factor))：这个表示的就是减速，factor和上面的加速参数是一个意思，只不过作用是相反的，也可以不带参数new 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;
}

４。setInterpolator(new 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;
}

５。setInterpolator(new 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;
    }
}

６。setInterpolator(new 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;
    }
}

７。setInterpolator(new BounceInterpolator())：跳跃，快到目的值时值会跳跃，如目的值100，后面的值可能依次为85，77，70，80，90，100

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

 

８。setInterpolator(new 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);
    }
}

９。setInterpolator(new 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);
    }
}

就上面这么多了，按照上面的代码我们也可以自定义我们符合我们自己的Interpolator,定义方法就是写一个类继承于Interpolator接口，并且去实现getInterpolation()方法，在该方法里面做相应的运算。

常用的方法就上面这些，来看一下一个ScaleAnimation用法，其它类似：

    private ScaleAnimation scale(){
        ScaleAnimation scaleAnimation=new ScaleAnimation(0, 1, 0, 1, Animation.RELATIVE_TO_SELF, 0.5f, Animation.RELATIVE_TO_SELF, 0.5f);
        scaleAnimation.setDuration(1000);
        scaleAnimation.setStartOffset(0);
        scaleAnimation.setInterpolator(new AccelerateInterpolator());
        scaleAnimation.setFillAfter(true);
        return scaleAnimation;
    }

 开启这个动画在一个按钮上面

        imageView=(ImageView) findViewById(R.id.image);
        scaleBtn.setOnClickListener(new OnClickListener() {
            
            @Override
            public void onClick(View v) {
                // TODO Auto-generated method stub
                imageView.startAnimation(scale());
            }
        });

上面这个就实现图片放大缩小的效果

如果我们想要实现两种以上的动画如何处理呢，这个时候我们就可以使用AnimationSet这个类实现多个动画叠加效果，

 

AnimationSet(boolean shareInterpolator);

 

这个参数设为false表示可以在每个添加到AnimationSet中的Animation都使用Interpolator，且效果都能清楚的观察。设置为true如果在添加到AnimationSet中的Animation设置Interpolator将无效果，通过设置AnimationSet的Interpolator可以设置所有动画的Interpolator且所有动画的Interpolator都一样。

    private AnimationSet allAnimation(){
        AnimationSet set=new AnimationSet(boolean shareInterpolator);
        TranslateAnimation translate=new TranslateAnimation(0, 100, 0, 100);
        RotateAnimation rotate=new RotateAnimation(0, 50, Animation.RELATIVE_TO_SELF, 0.5f, Animation.RELATIVE_TO_SELF, 0.5f);
        set.addAnimation(translate);
        set.addAnimation(rotate);
        set.setInterpolator(new AnticipateOvershootInterpolator());
        set.setFillAfter(true);
        set.setDuration(1000);
        set.setStartOffset(100);
        return set;
        
    }

我们看到addAnimation就是添加动画效果，其它方法和那个是一样的

我们在使用的过程有时候需要监听动画的开始和结束，AnimationListener这个就是动画监听

        set.setAnimationListener(new AnimationListener() {
            
            @Override
            public void onAnimationStart(Animation animation) {
                // TODO Auto-generated method stub
                
            }
            
            @Override
            public void onAnimationRepeat(Animation animation) {
                // TODO Auto-generated method stub
                
            }
            
            @Override
            public void onAnimationEnd(Animation animation) {
                // TODO Auto-generated method stub
                
            }
        });

看上面的意思就会明白那个是表示动画的开始，那个是动画结束了

这个我们可以在res／anim目录中通过xml来写动画

xml version="1.0" encoding="utf-8"?>
<set xmlns:android="http://schemas.android.com/apk/res/android">
    <alpha 
        android:fromAlpha="0"
        android:toAlpha="1"
        android:duration="1000"
        />
    <translate 
        android:interpolator="@android:anim/accelerate_decelerate_interpolator"
        android:fromXDelta="0"
        android:toXDelta="100"
        android:fromYDelta="0"
        android:toYDelta="100"
        android:startOffset="50"
        android:duration="1000"
        />

set>

上面就是xml写的，那么如何加载呢？看下面的代码

                Animation an=AnimationUtils.loadAnimation(AnimationTest.this, R.anim.itchqanimator);
                imageView.startAnimation(an);

这个就是加载xml里面的动画的

Property Animation

这个是属性动画，是android4.0引入手机中（android 3.0中就有了只是３.0主要的在平板电脑上使用的），我们上面讲解的那种tween Animation动画改变的是view绘制，而没有改变View对象本身，比如，你有一个Button，坐标 （100,100），Width:200,Height:50，而你有一个动画使其变为Width：100，Height：100，你会发现动画过程中触 发按钮点击的区域仍是(100,100)-(300,150)。而在Property Animation中，改变的是对象的实际属性，而且Property Animation不止可以应用于View，还可以应用于任何对象。

ValueAnimator类就是这个的包含Property Animation的动画所以核心功能，如动画的时间，开始，结束的属性值等等，当时对于ValueAnimator来说我们一般都不会直接使用这个，我们都是直接使用ValueAnimator的子类就是ObjectAnimator。

ObjectAnimator是继承于ValueAnimator的，使用这个ObjectAnimator是有条件限制的

１。对象应该有一个setter函数：set（驼峰命名法），这个命名法可以上网查一下，很容易理解的

２。创建ObjectAnimation对象一般是

ObjectAnimator objectAnimator=ObjectAnimator.ofFloat(valueBtn, "alpha", 1f,0f);

像ofFloat之类的工场方法，第一个参数为对象名(这个也就是我们的view类了)，第二个为属性名，后面的参数为可变参 数，如果values…参数只设置了一个值的话，那么会假定为目的值，属性值的变化范围为当前值到目的值，为了获得当前值，该对象要有相应属性的 getter方法：get

３。如果有getter方法，其应返回值类型应与相应的setter方法的参数类型一致。正常情况驼峰命名法都是get和set方法对应的出现

        valueBtn=(Button) findViewById(R.id.valueAnimation);
        valueBtn.setOnClickListener(new OnClickListener() {
            
            @Override
            public void onClick(View v) {
                // TODO Auto-generated method stub
                ObjectAnimator objectAnimator=ObjectAnimator.ofFloat(valueBtn, "alpha", 1f,0f);
                objectAnimator.setDuration(1000);
                objectAnimator.start();
            }
        });

这个就是ObjectAnimator简单的用法，通过这个我们也可以监听动画的开始和结束，上面有介绍过AnimatorListener的监听，如下：

        objectAnimator.addListener(new AnimatorListener() {
            
            @Override
            public void onAnimationStart(Animator animation) {
                // TODO Auto-generated method stub
                
            }
            
            @Override
            public void onAnimationRepeat(Animator animation) {
                // TODO Auto-generated method stub
                
            }
            
            @Override
            public void onAnimationEnd(Animator animation) {
                // TODO Auto-generated method stub
                
            }
            
            @Override
            public void onAnimationCancel(Animator animation) {
                // TODO Auto-generated method stub
                
            }
        });

当是我们有时候不需要取监听动画的取消或者重复，这些代码在这里显然是多余的，这个时候我们就可以使用AnimatorListenerAdapter这个适配器来进行监听了，如下

        objectAnimator.addListener(new AnimatorListenerAdapter() {

            @Override
            public void onAnimationEnd(Animator animation) {
                // TODO Auto-generated method stub
                super.onAnimationEnd(animation);
            }

            @Override
            public void onAnimationStart(Animator animation) {
                // TODO Auto-generated method stub
                super.onAnimationStart(animation);
            }
            
        });

这个就只关心我们的动画开始和介绍，其它就不需要了，代码看起来简洁了很多。ObjectAnimator当然也有setInterpolator()和setStartDelay()等一系列方法，这些的话就和我们上面的说的tween Animation动画方法是一样的。如果我们想要同时实现很多个动画就需要AnimatorSet这个类来实现，如下代码：

        AnimatorSet set=new AnimatorSet();
        ObjectAnimator alphaAnimator=ObjectAnimator.ofFloat(valueBtn, "alpha", 0f,1f);
    
        
        ObjectAnimator  xAnimator=ObjectAnimator.ofFloat(valueBtn, "translationX", 0f,5f,10f);
        
        ObjectAnimator  yAnimator=ObjectAnimator.ofFloat(valueBtn, "translationY", 0f,5f,10f);
        
        ObjectAnimator  rotateYAnimator=ObjectAnimator.ofFloat(valueBtn, "rotationX", 0f,90f);
        
        set.play(alphaAnimator).before(xAnimator);
        set.play(xAnimator).with(yAnimator);
        set.play(yAnimator).after(rotateYAnimator);
        set.setDuration(2000);
        set.start();

 

上面就是使用AnimatorSet方法，这个方法提供了before,with,after方法，按上面代码的意思就是alphaAnimator先执行，之后到xAnimator，yAnimator和xAnimator是同时执行的，执行完yAnimator和xAnimator之后就执行rotateYAnimator，看上面的字面意思也很容易理解了。

在实现过程中经常使用一些动画属性：

１。translationX,translationY,x,y

这些translationX和x，TranslationY和y是用区别的，下面来看看这个区别在哪里（我们这里以X坐标为例）

 

        valueBtn=(Button) findViewById(R.id.valueAnimation);
        Log.i("itchq", "valueBtn.getLeft()="+valueBtn.getLeft());
        Log.i("itchq", "valueBtn.getX()="+valueBtn.getX());
        Log.i("itchq", "valueBtn.getTranslationX()="+valueBtn.getTranslationX());

 

上面的代码中看一默认打印的信息是：

这个默认都是为０的，当我使用translationX动画之后

                ObjectAnimator objectAnimator=ObjectAnimator.ofFloat(valueBtn, "translationX", 0f,100f);
                objectAnimator.setDuration(1000);
                objectAnimator.start();
                objectAnimator.addListener(new AnimatorListenerAdapter() {

                    @Override
                    public void onAnimationEnd(Animator animation) {
                        // TODO Auto-generated method stub
                        Log.i("itchq", "valueBtn.getLeft()="+valueBtn.getLeft());
                        Log.i("itchq", "valueBtn.getX()="+valueBtn.getX());
                        Log.i("itchq", "valueBtn.getTranslationX()="+valueBtn.getTranslationX());
                    }
                    
                });

动画结束之后打印的信息如下

 

 这个时候我们再使用x动画之后

 

还是一样的，这个主要是因为这个getLeft为０，那么我们这个时候把getLeft设置为２０时，当是translationX时动画之后打出的log是

这个时候的x不再是１００了而是１２０了，再设置为x,看一下结果

这个时候的getTranslationX()不再是１００了，而是８０，所以无论啥样应用动画，getLeft的值是不会变的，而TranslationX的值是为最终位置于布局时初始位置的差，即“最终位置－getLeft()",而x为最终位置之和，即”getLeft()+getTranslationX()“,所以当getLeft为０的时候就会发现两个值是相等的。

２。rotation,rotationX,rotationY:旋转，rotation用于2D旋转角度，3D中用到后两个

３。scaleX,scaleY:缩放

４。alpha:透明度

 

Keyframe

keyFrame是一个 时间/值 对，通过它可以定义一个在特定时间的特定状态，而且在两个keyFrame之间可以定义不同的Interpolator，就相当多个动画的拼接，第一个动 画的结束点是第二个动画的开始点。KeyFrame是抽象类，要通过ofInt(),ofFloat(),ofObject()获得适当的 KeyFrame，然后通过PropertyValuesHolder.ofKeyframe获得PropertyValuesHolder对象，如以下代码：

        Keyframe kf0 = Keyframe.ofInt(0, 400);
        Keyframe kf1 = Keyframe.ofInt(0.25f, 200);
        Keyframe kf2 = Keyframe.ofInt(0.5f, 400);
        Keyframe kf4 = Keyframe.ofInt(0.75f, 100);
        Keyframe kf3 = Keyframe.ofInt(1f, 500);
        PropertyValuesHolder pvhRotation = PropertyValuesHolder.ofKeyframe("width", kf0, kf1, kf2, kf4, kf3);
        ObjectAnimator widthAnim = ObjectAnimator.ofPropertyValuesHolder(valueBtn, pvhRotation);
        widthAnim.setDuration(2000);
        widthAnim.start();

 

上述代码的意思为：设置valueBtn对象的width属性值使其：
开始时 Width=400
动画开始1/4时 Width=200
动画开始1/2时 Width=400
动画开始3/4时 Width=100
动画结束时 Width=500

第一个参数为时间百分比，第二个参数是在第一个参数的时间时的属性值。定义了一些Keyframe后，通过PropertyValuesHolder类的方法ofKeyframe封装，然后通过ObjectAnimator.ofPropertyValuesHolder获得Animator。

　　PropertyValuesHolder

如果需要对一个View的多个属性进行动画可以用ViewPropertyAnimator类，该类对多属性动画进行了优化，会合并一些invalidate()来减少刷新视图

        PropertyValuesHolder pvhX = PropertyValuesHolder.ofFloat("x", 50f);
        PropertyValuesHolder pvhY = PropertyValuesHolder.ofFloat("y", 100f);
        ObjectAnimator x_yAnimator=ObjectAnimator.ofPropertyValuesHolder(valueBtn, pvhX, pvhY);
        x_yAnimator.setDuration(1000);
        x_yAnimator.start();

上面这段代码就是同时进行X轴和Y轴的动画

 

 

 

转载于:https://www.cnblogs.com/itchq/p/3920725.html