android开发笔记之属性动画

属性动画简单介绍

作用对象：任意 Java 对象
不再局限于 视图View对象
实现的动画效果：可自定义各种动画效果
不再局限于4种基本变换：平移、旋转、缩放 & 透明度

特点
作用对象进行了扩展：不只是View对象，甚至没对象也可以
动画效果：不只是4种基本变换，还有其他动画效果
作用领域：API11后引入的

工作原理:
在一定时间间隔内，通过不断对值进行改变，并不断将该值赋给对象的属性，从而实现该对象在该属性上的动画效果

属性动画有两个非常重要的类：

ValueAnimator 类 & ObjectAnimator 类

ObjectAnimator类

具体使用

设置方式1：Java 设置

ObjectAnimator animator = ObjectAnimator.ofFloat(Object object, String property, float ....values);  
// ofFloat()作用有两个
// 1. 创建动画实例
// 2. 参数设置：参数说明如下
// Object object：需要操作的对象
// String property：需要操作的对象的属性
// float ....values：动画初始值 & 结束值（不固定长度）
// 若是两个参数a,b，则动画效果则是从属性的a值到b值
// 若是三个参数a,b,c，则则动画效果则是从属性的a值到b值再到c值
// 以此类推
// 至于如何从初始值 过渡到 结束值，同样是由估值器决定，此处ObjectAnimator.ofFloat（）是有系统内置的浮点型估值器FloatEvaluator，同ValueAnimator讲解

anim.setDuration(500); // 设置动画运行的时长

anim.setStartDelay(500);// 设置动画延迟播放时间

anim.setRepeatCount(0);
// 设置动画重复播放次数 = 重放次数+1
// 动画播放次数 = infinite时,动画无限重复

anim.setRepeatMode(ValueAnimator.RESTART);
// 设置重复播放动画模式
// ValueAnimator.RESTART(默认):正序重放
// ValueAnimator.REVERSE:倒序回放

animator.start();  
// 启动动画

设置方法2：在XML 代码中设置
步骤1：在路径 res/animator 的文件夹里创建动画效果.xml文件
此处设置为res/animator/set_animation.xml

步骤2：设置动画参数
set_animation.xml

// ObjectAnimator 采用  标签
  

在Java代码中启动动画

Animator animator = AnimatorInflater.loadAnimator(context, R.animator.view_animation);  
// 载入XML动画
animator.setTarget(view);  // 设置动画对象
animator.start();  // 启动动画

四种基本Demo

四种基本变换：透明度,旋转,平移,缩放

(1)透明度:

布局文件activity_main.xml:

实现代码MainActivity.java：

import android.animation.ObjectAnimator;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;

public class MainActivity extends AppCompatActivity {

    private Button mButton;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        init();
    }

    private void init() {
        mButton = (Button) findViewById(R.id.button);
        mButton.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                onDoAnimator();
            }
        });
    }

    private void onDoAnimator() {
        ObjectAnimator animator = ObjectAnimator.ofFloat(mButton, "alpha", 1f, 0f, 1f);
        // 动画作用对象是mButton
        // 动画作用的对象的属性是透明度alpha
        // 动画效果是:常规 - 全透明 - 常规
        animator.setDuration(5000);
        animator.start();
    }
}

动画效果：

(2)旋转:

    private void onDoAnimator() {
        ObjectAnimator animator = ObjectAnimator.ofFloat(mButton, "rotation", 0f, 360f);
        // 动画作用对象是mButton
        // 动画作用的对象的属性是旋转alpha
        // 动画效果是:0 - 360
        animator.setDuration(5000);
        animator.start();
    }

动画效果：

(3)平移

private void onDoAnimator() {
    float curTranslationX = mButton.getTranslationX();
    // 获得当前按钮的位置
    ObjectAnimator animator = ObjectAnimator.ofFloat(mButton, "translationX", curTranslationX, 300,curTranslationX,-300,curTranslationX);
    // 动画作用对象是mButton
    // 动画作用的对象的属性是X轴平移（在Y轴上平移同理，采用属性"translationY"
    // 动画效果是:从当前位置平移到 x=300 再平移到初始位置
    animator.setDuration(5000);
    animator.start();
}

动画效果：

(4)缩放

private void onDoAnimator() {
    ObjectAnimator animator = ObjectAnimator.ofFloat(mButton, "scaleX", 1f, 1.5f, 1f);
    // 表示的是:
    // 动画作用对象是mButton
    // 动画作用的对象的属性是X轴缩放
    // 动画效果是:放大到3倍,再缩小到初始大小
    animator.setDuration(5000);
    animator.start();
}

动画效果：

在ObjectAnimator.ofFloat（）的第二个参数String property传入alpha、rotation、translationX 和 scaleY 等：

属性	作用	数值类型
Alpha	控制View的透明度	float
TranslationX	控制X方向的位移	float
TranslationY	控制Y方向的位移	float
ScaleX	控制X方向的缩放倍数	float
ScaleY	控制Y方向的缩放倍数	float
Rotation	控制以屏幕方向为轴的旋转度数	float
RotationX	控制以X轴为轴的旋转度数	float
RotationY	控制以Y轴为轴的旋转度数	float

问题：那么ofFloat()的第二个参数还能传入什么属性值呢？
答案：任意属性值。

因为：

• ObjectAnimator 类 对 对象属性值 进行改变从而实现动画效果的本质是：通过不断控制 值 的变化，再不断 自动
  赋给对象的属性，从而实现动画效果
• 而自动赋给对象的属性的本质是调用该对象属性的set（） & get（）方法进行赋值
• 所以，ObjectAnimator.ofFloat(Object object, String property, float
  …values)的第二个参数传入值的作用是：让ObjectAnimator类根据传入的属性名 去寻找 该对象对应属性名的 set（）& get（）方法，从而进行对象属性值的赋值

通过自定义对象属性实现动画效果

对于属性动画，其拓展性在于：不局限于系统限定的动画，可以自定义动画，即自定义对象的属性，并通过操作自定义的属性从而实现动画。
那么，该如何自定义属性呢？本质上，就是：
为对象设置需要操作属性的set（） & get（）方法
通过实现TypeEvaluator类从而定义属性变化的逻辑

实现的动画效果：一个圆的颜色渐变

(1)定义MyView2 ：

import android.content.Context;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.util.AttributeSet;
import android.view.View;

public class MyView2 extends View {

    // 设置需要用到的变量
    public static final float RADIUS = 100f;// 圆的半径 = 100
    private Paint mPaint;// 绘图画笔

    private String color;// 设置背景颜色属性

    // 设置背景颜色的get() & set()方法
    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
        mPaint.setColor(Color.parseColor(color));
        // 将画笔的颜色设置成方法参数传入的颜色
        invalidate();
        // 调用了invalidate()方法,即画笔颜色每次改变都会刷新视图，然后调用onDraw()方法重新绘制圆
        // 而因为每次调用onDraw()方法时画笔的颜色都会改变,所以圆的颜色也会改变
    }


    // 构造方法(初始化画笔)
    public MyView2(Context context, AttributeSet attrs) {
        super(context, attrs);
        // 初始化画笔
        mPaint = new Paint(Paint.ANTI_ALIAS_FLAG);
        mPaint.setColor(Color.BLUE);
    }

    // 绘制逻辑:先在初始点画圆,通过监听当前坐标值(currentPoint)的变化,每次变化都调用onDraw()重新绘制圆,从而实现圆的平移动画效果
    @Override
    protected void onDraw(Canvas canvas) {
        canvas.drawCircle(500, 500, RADIUS, mPaint);
    }
}

(2)在布局文件activity_main.xml中引用MyView2：

    
        />

(3)实现TypeEvaluator需求接口,实现 颜色过渡的逻辑

import android.animation.TypeEvaluator;

public class ColorEvaluator implements TypeEvaluator {
    // 实现TypeEvaluator接口

    private int mCurrentRed;
    private int mCurrentGreen ;
    private int mCurrentBlue ;

    // 在evaluate（）里写入对象动画过渡的逻辑:此处是写颜色过渡的逻辑
    @Override
    public Object evaluate(float fraction, Object startValue, Object endValue) {

        // 获取到颜色的初始值和结束值
        String startColor = (String) startValue;
        String endColor = (String) endValue;

        // 通过字符串截取的方式将初始化颜色分为RGB三个部分，并将RGB的值转换成十进制数字
        // 那么每个颜色的取值范围就是0-255
        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);

        // 将初始化颜色的值定义为当前需要操作的颜色值
        mCurrentRed = startRed;
        mCurrentGreen = startGreen;
        mCurrentBlue = startBlue;

        // 计算初始颜色和结束颜色之间的差值
        // 该差值决定着颜色变化的快慢:初始颜色值和结束颜色值很相近，那么颜色变化就会比较缓慢;否则,变化则很快
        // 具体如何根据差值来决定颜色变化快慢的逻辑写在getCurrentColor()里.
        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);
            // getCurrentColor()决定如何根据差值来决定颜色变化的快慢 ->>关注1
        } else if (mCurrentGreen != endGreen) {
            mCurrentGreen = getCurrentColor(startGreen, endGreen, colorDiff,redDiff, fraction);
        } else if (mCurrentBlue != endBlue) {
            mCurrentBlue = getCurrentColor(startBlue, endBlue, colorDiff,redDiff + greenDiff, fraction);
        }
        // 将计算出的当前颜色的值组装返回
        String currentColor = "#" + getHexString(mCurrentRed) + getHexString(mCurrentGreen) + getHexString(mCurrentBlue);

        // 由于我们计算出的颜色是十进制数字，所以需要转换成十六进制字符串:调用getHexString()->>关注2
        // 最终将RGB颜色拼装起来,并作为最终的结果返回
        return currentColor;
    }


    // 关注1:getCurrentColor()
    // 具体是根据fraction值来计算当前的颜色。
    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;
    }

    // 关注2:将10进制颜色值转换成16进制。
    private String getHexString(int value) {
        String hexString = Integer.toHexString(value);
        if (hexString.length() == 1) {
            hexString = "0" + hexString;
        }
        return hexString;
    }

}

(4)调用ObjectAnimator.ofObject（）方法

import android.animation.ObjectAnimator;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;

public class MainActivity extends AppCompatActivity {

    private MyView2 myView2;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        init();
    }

    private void init() {
        myView2 = (MyView2) findViewById(R.id.myView2);
        ObjectAnimator anim = ObjectAnimator.ofObject(myView2, "color", new ColorEvaluator(),
                "#0000FF", "#FF0000");
        // 设置自定义View对象、背景颜色属性值 & 颜色估值器
        // 本质逻辑：
        // 步骤1：根据颜色估值器不断 改变 值
        // 步骤2：调用set（）设置背景颜色的属性值（实际上是通过画笔进行颜色设置）
        // 步骤3：调用invalidate()刷新视图，即调用onDraw（）重新绘制，从而实现动画效果

        anim.setDuration(8000);
        anim.start();
    }

}

下面的例子是我们android源码中的颜色改变的动画：

(1) packages\apps\TV\src\com\android\tv\dvr\ui\FadeBackground.java

    public Animator createAnimator(ViewGroup sceneRoot, TransitionValues startValues,
            TransitionValues endValues) {
        if (startValues == null || endValues == null) {
            return null;
        }
        Drawable background = endValues.view.getBackground();
        if (background instanceof ColorDrawable) {
            int color = ((ColorDrawable) background).getColor();
            int transparentColor = Color.argb(0, Color.red(color), Color.green(color),
                    Color.blue(color));
            return mMode == Visibility.MODE_OUT
                    ? ObjectAnimator.ofArgb(background, "color", transparentColor)
                    : ObjectAnimator.ofArgb(background, "color", transparentColor, color);
        }
        return null;
    }

(2)packages/apps/Launcher3/src/com/android/launcher3/ButtonDropTarget.java

public abstract class ButtonDropTarget extends TextView
        implements DropTarget, DragController.DragListener, OnClickListener {
....................
       private void animateTextColor(int targetColor) {
        	mCurrentColorAnim = new AnimatorSet();
        	mCurrentColorAnim.setDuration(DragView.COLOR_CHANGE_DURATION);
        	mCurrentColorAnim.play(ObjectAnimator.ofArgb(this, "textColor", targetColor));
        	mCurrentColorAnim.start();

}

可以看出，这个更简洁。

ValueAnimator类

具体使用

属性动画机制中最核心的一个类,实现动画的原理：通过不断控制值的变化，再不断手动赋给对象的属性，从而实现动画效果.

ValueAnimator类中有3个重要方法：

ValueAnimator.ofInt（int values）
ValueAnimator.ofFloat（float values）
ValueAnimator.ofObject（int values）

ValueAnimator.ofInt（int values）

具体使用

作用：将初始值 以整型数值的形式 过渡到结束值
即估值器是整型估值器 - IntEvaluator

设置方式1：Java代码设置

// 步骤1：设置动画属性的初始值 & 结束值
ValueAnimator anim = ValueAnimator.ofInt(0, 3);
        // ofInt（）作用有两个
        // 1. 创建动画实例
        // 2. 将传入的多个Int参数进行平滑过渡:此处传入0和1,表示将值从0平滑过渡到1
        // 如果传入了3个Int参数 a,b,c ,则是先从a平滑过渡到b,再从b平滑过渡到C，以此类推
        // ValueAnimator.ofInt()内置了整型估值器,直接采用默认的.不需要设置，即默认设置了如何从初始值 过渡到 结束值
        // 关于自定义插值器我将在下节进行讲解
        // 下面看看ofInt()的源码分析 ->>关注1
        
// 步骤2：设置动画的播放各种属性
        anim.setDuration(500);
        // 设置动画运行的时长
        anim.setStartDelay(500);
        // 设置动画延迟播放时间
        anim.setRepeatCount(0);
        // 设置动画重复播放次数 = 重放次数+1
        // 动画播放次数 = infinite时,动画无限重复
        anim.setRepeatMode(ValueAnimator.RESTART);
        // 设置重复播放动画模式
        // ValueAnimator.RESTART(默认):正序重放
        // ValueAnimator.REVERSE:倒序回放
     
// 步骤3：将改变的值手动赋值给对象的属性值：通过动画的更新监听器
        // 设置 值的更新监听器
        // 即：值每次改变、变化一次,该方法就会被调用一次
        anim.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
            @Override
            public void onAnimationUpdate(ValueAnimator animation) {

                int currentValue = (Integer) animation.getAnimatedValue();
                // 获得改变后的值
                
                System.out.println(currentValue);
                // 输出改变后的值

        // 步骤4：将改变后的值赋给对象的属性值，下面会详细说明
                View.setproperty（currentValue）；

       // 步骤5：刷新视图，即重新绘制，从而实现动画效果
                View.requestLayout();
            }
        });

        anim.start();
        // 启动动画
    }

// 关注1：ofInt（）源码分析
    public static ValueAnimator ofInt(int... values) {
        // 允许传入一个或多个Int参数
        // 1. 输入一个的情况（如a）：从0过渡到a；
        // 2. 输入多个的情况（如a，b，c）：先从a平滑过渡到b，再从b平滑过渡到C
        
        ValueAnimator anim = new ValueAnimator();
        // 创建动画对象
        anim.setIntValues(values);
        // 将传入的值赋值给动画对象
        return anim;
    }

设置方法2：在XML 代码中设置
具备重用性，即将通用的动画写到XML里，可在各个界面中去重用它

• 步骤1：在路径 res/animator的文件夹里创建相应的动画 .xml文件
  此处设置为res/animator/set_animation.xml
• 步骤2：设置动画参数
  set_animation.xml

// ValueAnimator采用  标签
  

• 步骤3：在Java代码中启动动画

Animator animator = AnimatorInflater.loadAnimator(context, R.animator.set_animation);  
// 载入XML动画
animator.setTarget(view);  
// 设置动画对象
animator.start();  
// 启动动画

实现的动画效果：按钮的宽度从 150px 放大到 500px

我将结合 手动赋值给对象属性 这一步骤，从而实现一个完整的动画效果。

public class MainActivity extends AppCompatActivity {

    private Button mButton;
    private ValueAnimator valueAnimator;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        init();
    }

    private void init() {
        mButton = (Button) findViewById(R.id.button);
        mButton.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                onDoAnimator();
            }
        });

// 步骤1：设置属性数值的初始值 & 结束值
        System.out.println(mButton.getLayoutParams().width);
        valueAnimator = ValueAnimator.ofInt(150, 500);
        // 初始值 150
        // 结束值 = 500
        // ValueAnimator.ofInt()内置了整型估值器,直接采用默认的.不需要设置
        // 即默认设置了如何从初始值150 过渡到 结束值500

// 步骤2：设置动画的播放各种属性
        valueAnimator.setDuration(2000);
        // 设置动画运行时长:1s

// 步骤3：将属性数值手动赋值给对象的属性:此处是将 值 赋给 按钮的宽度
        // 设置更新监听器：即数值每次变化更新都会调用该方法
        valueAnimator.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
            @Override
            public void onAnimationUpdate(ValueAnimator animator) {

                int currentValue = (Integer) animator.getAnimatedValue();
                // 获得每次变化后的属性值
                System.out.println(currentValue);
                // 输出每次变化后的属性值进行查看

                mButton.getLayoutParams().width = currentValue;
                // 每次值变化时，将值手动赋值给对象的属性
                // 即将每次变化后的值 赋 给按钮的宽度，这样就实现了按钮宽度属性的动态变化

// 步骤4：刷新视图，即重新绘制，从而实现动画效果
                mButton.requestLayout();

            }
        });
    }

    private void onDoAnimator() {
        // 启动动画
        valueAnimator.start();
    }
}

动画效果图：

ValueAnimator.oFloat（float values）

作用：将初始值 以浮点型数值的形式 过渡到结束值

具体使用：

分为 XML 设置 / Java 代码设置
设置方法1：在 Java 代码中设置

ValueAnimator anim = ValueAnimator.ofFloat(0, 3);  
// 其他使用类似ValueAnimator.ofInt（int values），此处不作过多描述

设置方法2：在XML 代码中设置
步骤1：在路径 res/animator的文件夹里创建相应的动画.xml文件
此处设置为res/animator/set_animation.xml
步骤2：设置动画参数
set_animation.xml

// ValueAnimator采用  标签
  

步骤3：在Java代码中启动动画

Animator animator = AnimatorInflater.loadAnimator(context, R.animator.set_animation);  
// 载入XML动画
animator.setTarget(view);  
// 设置动画对象
animator.start();  
// 启动动画

ValueAnimator.oFloat（）采用默认的浮点型估值器 (FloatEvaluator)
ValueAnimator.ofInt（）采用默认的整型估值器（IntEvaluator）

ValueAnimator.ofObject（）
作用：将初始值 以对象的形式 过渡到结束值
即通过操作 对象 实现动画效果
具体使用：

// 创建初始动画时的对象  & 结束动画时的对象
myObject object1 = new myObject();  
myObject object2 = new myObject();  

ValueAnimator anim = ValueAnimator.ofObject(new myObjectEvaluator(), object1, object2);  
// 创建动画对象 & 设置参数
// 参数说明
// 参数1：自定义的估值器对象（TypeEvaluator 类型参数） - 下面会详细介绍
// 参数2：初始动画的对象
// 参数3：结束动画的对象
anim.setDuration(5000);  
anim.start(); 

先讲一下估值器（TypeEvaluator）

估值器（TypeEvaluator） 介绍

作用：设置动画 如何从初始值 过渡到 结束值 的逻辑
插值器（Interpolator）决定 值 的变化模式（匀速、加速等）
估值器（TypeEvaluator）决定 值 的具体变化数值
我们来看一下 FloatEvaluator的代码实现：

public class FloatEvaluator implements TypeEvaluator {  
// FloatEvaluator实现了TypeEvaluator接口

// 重写evaluate()
    public Object evaluate(float fraction, Object startValue, Object endValue) {  
// 参数说明
// fraction：表示动画完成度（根据它来计算当前动画的值）
// startValue、endValue：动画的初始值和结束值
        float startFloat = ((Number) startValue).floatValue();  
        
        return startFloat + fraction * (((Number) endValue).floatValue() - startFloat);  
        // 初始值 过渡 到结束值 的算法是：
        // 1. 用结束值减去初始值，算出它们之间的差值
        // 2. 用上述差值乘以fraction系数
        // 3. 再加上初始值，就得到当前动画的值
    }  
}  

自定义实现的逻辑如下

// 实现TypeEvaluator接口
public class ObjectEvaluator implements TypeEvaluator{  

// 复写evaluate（）
// 在evaluate（）里写入对象动画过渡的逻辑
    @Override  
    public Object evaluate(float fraction, Object startValue, Object endValue) {  
        // 参数说明
        // fraction：表示动画完成度（根据它来计算当前动画的值）
        // startValue、endValue：动画的初始值和结束值

        ... // 写入对象动画过渡的逻辑
        
        return value;  
        // 返回对象动画过渡的逻辑计算后的值
    }  
  

实现的动画效果：一个圆从一个点 移动到 另外一个点

步骤1：定义对象类

public class Point {

    // 设置两个变量用于记录坐标的位置
    private float x;
    private float y;

    // 构造方法用于设置坐标
    public Point(float x, float y) {
        this.x = x;
        this.y = y;
    }

    // get方法用于获取坐标
    public float getX() {
        return x;
    }

    public float getY() {
        return y;
    }
}

步骤2：根据需求实现TypeEvaluator接口
实现TypeEvaluator接口的目的是自定义如何 从初始点坐标 过渡 到结束点坐标；
本例实现的是一个从左上角到右下角的坐标过渡逻辑。
PointEvaluator.java

import android.animation.TypeEvaluator;

// 实现TypeEvaluator接口
public class PointEvaluator implements TypeEvaluator {

    // 复写evaluate（）
    // 在evaluate（）里写入对象动画过渡的逻辑
    @Override
    public Object evaluate(float fraction, Object startValue, Object endValue) {

        // 将动画初始值startValue 和 动画结束值endValue 强制类型转换成Point对象
        Point startPoint = (Point) startValue;
        Point endPoint = (Point) endValue;

        // 根据fraction来计算当前动画的x和y的值
        float x = startPoint.getX() + fraction * (endPoint.getX() - startPoint.getX());
        float y = startPoint.getY() + fraction * (endPoint.getY() - startPoint.getY());
        
        // 将计算后的坐标封装到一个新的Point对象中并返回
        Point point = new Point(x, y);
        return point;
    }

}

步骤3：将属性动画作用到自定义View当中
MyView.java

import android.animation.ValueAnimator;
import android.content.Context;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.util.AttributeSet;
import android.view.View;

public class MyView extends View {
    // 设置需要用到的变量
    public static final float RADIUS = 70f;// 圆的半径 = 70
    private Point currentPoint;// 当前点坐标
    private Paint mPaint;// 绘图画笔


    // 构造方法(初始化画笔)
    public MyView(Context context, AttributeSet attrs) {
        super(context, attrs);
        // 初始化画笔
        mPaint = new Paint(Paint.ANTI_ALIAS_FLAG);
        mPaint.setColor(Color.BLUE);
    }

    // 复写onDraw()从而实现绘制逻辑
    // 绘制逻辑:先在初始点画圆,通过监听当前坐标值(currentPoint)的变化,每次变化都调用onDraw()重新绘制圆,从而实现圆的平移动画效果
    @Override
    protected void onDraw(Canvas canvas) {
        // 如果当前点坐标为空(即第一次)
        if (currentPoint == null) {
            currentPoint = new Point(RADIUS, RADIUS);
            // 创建一个点对象(坐标是(70,70))

            // 在该点画一个圆:圆心 = (70,70),半径 = 70
            float x = currentPoint.getX();
            float y = currentPoint.getY();
            canvas.drawCircle(x, y, RADIUS, mPaint);


            // (重点关注)将属性动画作用到View中
            // 步骤1:创建初始动画时的对象点  & 结束动画时的对象点
            Point startPoint = new Point(RADIUS, RADIUS);// 初始点为圆心(70,70)
            Point endPoint = new Point(700, 1000);// 结束点为(700,1000)

            // 步骤2:创建动画对象 & 设置初始值 和 结束值
            ValueAnimator anim = ValueAnimator.ofObject(new PointEvaluator(), startPoint, endPoint);
            // 参数说明
            // 参数1：TypeEvaluator 类型参数 - 使用自定义的PointEvaluator(实现了TypeEvaluator接口)
            // 参数2：初始动画的对象点
            // 参数3：结束动画的对象点

            // 步骤3：设置动画参数
            anim.setDuration(5000);
            // 设置动画时长

// 步骤3：通过 值 的更新监听器，将改变的对象手动赋值给当前对象
// 此处是将 改变后的坐标值对象 赋给 当前的坐标值对象
            // 设置 值的更新监听器
            // 即每当坐标值（Point对象）更新一次,该方法就会被调用一次
            anim.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
                @Override
                public void onAnimationUpdate(ValueAnimator animation) {
                    currentPoint = (Point) animation.getAnimatedValue();
                    // 将每次变化后的坐标值（估值器PointEvaluator中evaluate（）返回的Piont对象值）到当前坐标值对象（currentPoint）
                    // 从而更新当前坐标值（currentPoint）

// 步骤4：每次赋值后就重新绘制，从而实现动画效果
                    invalidate();
                    // 调用invalidate()后,就会刷新View,即才能看到重新绘制的界面,即onDraw()会被重新调用一次
                    // 所以坐标值每改变一次,就会调用onDraw()一次
                }
            });

            anim.start();
        } else {
            // 如果坐标值不为0,则画圆
            // 所以坐标值每改变一次,就会调用onDraw()一次,就会画一次圆,从而实现动画效果

            // 在该点画一个圆:圆心 = (30,30),半径 = 30
            float x = currentPoint.getX();
            float y = currentPoint.getY();
            canvas.drawCircle(x, y, RADIUS, mPaint);
        }
    }

}

步骤4：在布局文件activity_main.xml 加入自定义View空间

        
            />

步骤5：在主代码文件设置显示视图
MainActivity.java

import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
    }
}

动画效果:

android源码样例

下这个这是来电接听界面的动画实现：
packages/apps/Dialer/java/com/android/incallui/answer/impl/affordance/SwipeButtonView.java

/** Button that allows swiping to trigger */
public class SwipeButtonView extends ImageView {
....................................
  @Override
  protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
    super.onLayout(changed, left, top, right, bottom);
    centerX = getWidth() / 2;
    centerY = getHeight() / 2;
    maxCircleSize = getMaxCircleSize();
  }

  @Override
  protected void onDraw(Canvas canvas) {
    drawBackgroundCircle(canvas);
    canvas.save();
    canvas.scale(tmageScale, tmageScale, getWidth() / 2, getHeight() / 2);
    super.onDraw(canvas);
    canvas.restore();
  }
....................................
  private ValueAnimator getAnimatorToRadius(float circleRadius) {
    ValueAnimator animator = ValueAnimator.ofFloat(this.circleRadius, circleRadius);
    circleAnimator = animator;
    circleStartValue = this.circleRadius;
    circleWillBeHidden = circleRadius == 0.0f;
    animator.addUpdateListener(
        new ValueAnimator.AnimatorUpdateListener() {
          @Override
          public void onAnimationUpdate(ValueAnimator animation) {
            SwipeButtonView.this.circleRadius = (float) animation.getAnimatedValue();
            updateIconColor();
            invalidate();
          }
        });
    animator.addListener(circleEndListener);
    return animator;
  }
....................................
  public void setImageScale(
      float imageScale, boolean animate, long duration, @Nullable Interpolator interpolator) {
    cancelAnimator(scaleAnimator);
    if (!animate) {
      tmageScale = imageScale;
      invalidate();
    } else {
      ValueAnimator animator = ValueAnimator.ofFloat(tmageScale, imageScale);
      scaleAnimator = animator;
      animator.addUpdateListener(
          new ValueAnimator.AnimatorUpdateListener() {
            @Override
            public void onAnimationUpdate(ValueAnimator animation) {
              tmageScale = (float) animation.getAnimatedValue();
              invalidate();
            }
          });
      animator.addListener(scaleEndListener);
      if (interpolator == null) {
        interpolator =
            imageScale == 0.0f
                ? Interpolators.FAST_OUT_LINEAR_IN
                : Interpolators.LINEAR_OUT_SLOW_IN;
      }
      animator.setInterpolator(interpolator);
      if (duration == -1) {
        float durationFactor = Math.abs(tmageScale - imageScale) / (1.0f - MIN_ICON_SCALE_AMOUNT);
        durationFactor = Math.min(1.0f, durationFactor);
        duration = (long) (NORMAL_ANIMATION_DURATION * durationFactor);
      }
      animator.setDuration(duration);
      animator.start();
    }
  }
....................................
  public void setImageAlpha(
      float alpha,
      boolean animate,
      long duration,
      @Nullable Interpolator interpolator,
      @Nullable Runnable runnable) {
    cancelAnimator(alphaAnimator);
    alpha = launchingAffordance ? 0 : alpha;
    int endAlpha = (int) (alpha * 255);
    final Drawable background = getBackground();
    if (!animate) {
      if (background != null) {
        background.mutate().setAlpha(endAlpha);
      }
      setImageAlpha(endAlpha);
    } else {
      int currentAlpha = getImageAlpha();
      ValueAnimator animator = ValueAnimator.ofInt(currentAlpha, endAlpha);
      alphaAnimator = animator;
      animator.addUpdateListener(
          new ValueAnimator.AnimatorUpdateListener() {
            @Override
            public void onAnimationUpdate(ValueAnimator animation) {
              int alpha = (int) animation.getAnimatedValue();
              if (background != null) {
                background.mutate().setAlpha(alpha);
              }
              setImageAlpha(alpha);
            }
          });
      animator.addListener(alphaEndListener);
      if (interpolator == null) {
        interpolator =
            alpha == 0.0f ? Interpolators.FAST_OUT_LINEAR_IN : Interpolators.LINEAR_OUT_SLOW_IN;
      }
      animator.setInterpolator(interpolator);
      if (duration == -1) {
        float durationFactor = Math.abs(currentAlpha - endAlpha) / 255f;
        durationFactor = Math.min(1.0f, durationFactor);
        duration = (long) (NORMAL_ANIMATION_DURATION * durationFactor);
      }
      animator.setDuration(duration);
      if (runnable != null) {
        animator.addListener(getEndListener(runnable));
      }
      animator.start();
    }
  }

....................................

}

ValueAnimator类 & ObjectAnimator 类 总结:

对比ValueAnimator类 & ObjectAnimator 类，其实二者都属于属性动画，本质上都是一致的：先改变值，然后 赋值 给对象的属性从而实现动画效果。

ObjectAnimator与 ValueAnimator类的区别：

ValueAnimator 类是先改变值，然后 手动赋值 给对象的属性从而实现动画；是 间接 对对象属性进行操作；
ObjectAnimator 类是先改变值，然后 自动赋值 给对象的属性从而实现动画；是 直接 对对象属性进行操作；

ViewPropertyAnimator用法

具体使用

/ 使用解析
        View.animate().xxx().xxx();
        // ViewPropertyAnimator的功能建立在animate()上
        // 调用animate()方法返回值是一个ViewPropertyAnimator对象,之后的调用的所有方法都是通过该实例完成
        // 调用该实例的各种方法来实现动画效果
        // ViewPropertyAnimator所有接口方法都使用连缀语法来设计，每个方法的返回值都是它自身的实例
        // 因此调用完一个方法后可直接连缀调用另一方法,即可通过一行代码就完成所有动画效果
        
// 以下是例子
        mButton = (Button) findViewById(R.id.Button);
        // 创建动画作用对象：此处以Button为例

        mButton.animate().alpha(0f);
        // 单个动画设置:将按钮变成透明状态 
        mButton.animate().alpha(0f).setDuration(5000).setInterpolator(new BounceInterpolator());
        // 单个动画效果设置 & 参数设置 
        mButton.animate().alpha(0f).x(500).y(500);
        // 组合动画:将按钮变成透明状态再移动到(500,500)处
        
        // 特别注意:
        // 动画自动启动,无需调用start()方法.因为新的接口中使用了隐式启动动画的功能，只要我们将动画定义完成后，动画就会自动启动
        // 该机制对于组合动画也同样有效，只要不断地连缀新的方法，那么动画就不会立刻执行，等到所有在ViewPropertyAnimator上设置的方法都执行完毕后，动画就会自动启动
        // 如果不想使用这一默认机制，也可以显式地调用start()方法来启动动画

监听动画

Animation类通过监听动画开始 / 结束 / 重复 / 取消时刻来进行一系列操作，如跳转页面等等
通过在Java代码里addListener（）设置

Animation.addListener(new AnimatorListener() {
          @Override
          public void onAnimationStart(Animation animation) {
              //动画开始时执行
          }
      
           @Override
          public void onAnimationRepeat(Animation animation) {
              //动画重复时执行
          }

         @Override
          public void onAnimationCancel()(Animation animation) {
              //动画取消时执行
          }
    
          @Override
          public void onAnimationEnd(Animation animation) {
              //动画结束时执行
          }
      });

// 特别注意：每次监听必须4个方法都重写。

动画适配器AnimatorListenerAdapter

背景：有些时候我们并不需要监听动画的所有时刻
问题：但addListener(new AnimatorListener())监听器是必须重写4个时刻方法，这使得接口方法重写太累赘
解决方案：采用动画适配器（AnimatorListenerAdapter），解决实现接口繁琐 的问题

anim.addListener(new AnimatorListenerAdapter() {  
// 向addListener()方法中传入适配器对象AnimatorListenerAdapter()
// 由于AnimatorListenerAdapter中已经实现好每个接口
// 所以这里不实现全部方法也不会报错
    @Override  
    public void onAnimationStart(Animator animation) {  
    // 如想只想监听动画开始时刻，就只需要单独重写该方法就可以
    }  
});  

后记

这个属性动画，其实我好久前就知道这个知识点，知道她的重要性， 一直想弄真正的了解她，心里一直是惦记她，就像是一个心病一样。
但是啊，我的一位老朋友，老是和我说：下次吧，下次再看吧。而我有好几次有时间，都是大概的过一下。这个时候，这个老朋友又对我说：小明啊，可以了，这个就这样，走，我们吹水去。然后，然后我就和这个老朋友愉快的去吹水去了。生活就这样一直的浪下去了。
这个老朋友，他的名字就叫做“懒”。
哈哈！

参考资料

1.Android 属性动画：这是一篇很详细的 属性动画 总结&攻略
https://www.jianshu.com/p/2412d00a0ce4
2.android开发笔记之animation（一）
https://blog.csdn.net/hfreeman2008/article/details/39138303
3.Android 属性动画：这是一篇很详细的 属性动画 总结&攻略
https://www.jianshu.com/p/2412d00a0ce4