Android 动画机制总结与代码
一、核心知识点总结
1. 动画分类
- View 动画（补间动画）：包括平移、缩放、旋转、透明度，仅改变显示位置，不改变实际属性和响应区域。
- 帧动画：通过
AnimationDrawable 实现，本质是 Drawable 资源序列，易引发 OOM。
- 属性动画：可作用于任意对象的任意属性，真正改变属性值，支持响应区域更新。
2. View 动画特点
- 定义在
res/anim/
- 使用
AnimationUtils.loadAnimation() 加载 XML 动画
- 通过
startAnimation() 启动，clearAnimation() 取消
- 无法改变 View 的实际宽高、点击区域等
3. 属性动画核心类
ObjectAnimator：直接操作对象属性（需有对应 setter）ValueAnimator：仅计算值变化，需配合 UpdateListener 手动赋值AnimatorSet：组合多个动画- 定义在
res/animator/
4. 插值器（Interpolator）与估值器（Evaluator）
- 插值器：根据时间流逝百分比计算属性变化百分比（如
LinearInterpolator、DecelerateInterpolator）
- 估值器：根据插值器返回的百分比计算实际属性值（如
FloatEvaluator、ArgbEvaluator）
5. 特殊场景处理
- 对
width 等非直接支持属性做动画：使用包装类（Wrapper）提供 getter/setter
- Activity 切换动画：
overridePendingTransition()
- 避免内存泄漏：在 Activity 结束时取消动画
二、代码文件（带完整注释）
AnimActivity.kt
package com.shakespace.artofandroid.chapter07anim
import android.animation.ObjectAnimator
import android.os.Bundle
import android.view.View
import androidx.appcompat.app.AppCompatActivity
import com.shakespace.artofandroid.R
import com.shakespace.firstlinecode.global.start
import kotlinx.android.synthetic.main.activity_anim.*
/**
* 动画主入口 Activity
*/
class AnimActivity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_anim)
// 跳转到 View 动画演示页
tv_animation.setOnClickListener {
start(AnimationActivity::class.java)
overridePendingTransition(R.anim.act_enter, R.anim.act_exit)
}
// 跳转到属性动画演示页
tv_animator.setOnClickListener {
start(AnimatorActivity::class.java)
overridePendingTransition(R.anim.act_enter, R.anim.act_exit)
}
// 演示如何对 width 做属性动画（使用包装类）
tv_change_width.setOnClickListener {
ObjectAnimator.ofInt(ViewWrapper(tv_demo), "width", 500).start()
}
}
/**
* 包装 View，为 width 提供 getter/setter
* 解决属性动画无法直接操作 layoutParam 的问题
*/
inner class ViewWrapper(private val view: View) {
fun getWidth(): Int {
return view.layoutParams.width
}
fun setWidth(width: Int) {
view.layoutParams.width = width
view.requestLayout()
}
}
}
AnimationActivity.kt
package com.shakespace.artofandroid.chapter07anim
import android.graphics.drawable.AnimationDrawable
import android.os.Bundle
import android.util.Log
import android.view.animation.*
import androidx.appcompat.app.AppCompatActivity
import com.shakespace.artofandroid.R
import com.shakespace.firstlinecode.global.TAG
import kotlinx.android.synthetic.main.activity_animation.*
/**
* View 动画（补间动画 + 帧动画）演示
*/
class AnimationActivity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_animation)
// 透明度动画
val alpha = AlphaAnimation(1f, 0f).apply {
duration = 2000
repeatCount = -1
repeatMode = Animation.REVERSE
}
// 旋转动画（以自身中心为轴）
val rotate = RotateAnimation(
-90f, 270f,
RotateAnimation.RELATIVE_TO_SELF, 0.5f,
RotateAnimation.RELATIVE_TO_SELF, 0.5f
).apply {
duration = 1000
repeatCount = -1
repeatMode = Animation.REVERSE
}
// 缩放动画
val scale = ScaleAnimation(
0.5f, 2f, 0.2f, 3f,
ScaleAnimation.RELATIVE_TO_SELF, 0.5f,
ScaleAnimation.RELATIVE_TO_SELF, 0.5f
).apply {
duration = 1000
repeatCount = -1
repeatMode = Animation.REVERSE
}
// 平移动画
val trans = TranslateAnimation(
TranslateAnimation.RELATIVE_TO_SELF, 0f,
TranslateAnimation.RELATIVE_TO_SELF, 3f,
TranslateAnimation.RELATIVE_TO_SELF, 0f,
TranslateAnimation.RELATIVE_TO_SELF, 3f
).apply {
duration = 1000
repeatCount = -1
repeatMode = Animation.REVERSE
}
// 绑定点击事件
tv_alpha.setOnClickListener { iv_anim.startAnimation(alpha) }
tv_rotate.setOnClickListener { iv_anim.startAnimation(rotate) }
tv_scale.setOnClickListener { iv_anim.startAnimation(scale) }
tv_translation.setOnClickListener { iv_anim.startAnimation(trans) }
// 组合动画
tv_complex.setOnClickListener {
val set = AnimationSet(false).apply {
addAnimation(alpha)
addAnimation(rotate)
addAnimation(scale)
addAnimation(trans)
duration = 3000
}
iv_anim.startAnimation(set)
}
// 动画监听
trans.setAnimationListener(object : Animation.AnimationListener {
override fun onAnimationRepeat(animation: Animation?) {
Log.e(TAG, "onAnimationRepeat: ")
}
override fun onAnimationEnd(animation: Animation?) {
Log.e(TAG, "onAnimationEnd: ")
}
override fun onAnimationStart(animation: Animation?) {
Log.e(TAG, "onAnimationStart: ")
}
})
// 从 XML 加载动画
tv_xml.setOnClickListener {
iv_anim.startAnimation(AnimationUtils.loadAnimation(this, R.anim.alpha))
}
// 帧动画（需在 drawable 中定义）
tv_frame.setOnClickListener {
val animationDrawable = tv_frame.background as AnimationDrawable
animationDrawable.start()
}
}
override fun onBackPressed() {
super.onBackPressed()
overridePendingTransition(R.anim.act_back_enter, R.anim.act_back_exit)
}
}
AnimatorActivity.kt
package com.shakespace.artofandroid.chapter07anim
import android.animation.*
import android.os.Bundle
import android.util.Log
import androidx.appcompat.app.AppCompatActivity
import com.shakespace.artofandroid.R
import com.shakespace.firstlinecode.global.TAG
import kotlinx.android.synthetic.main.activity_animator.*
/**
* 属性动画演示
*/
class AnimatorActivity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_animator)
// 属性动画：alpha
val alphaAnimator = ObjectAnimator.ofFloat(iv_anim, "alpha", 0.5f)
// 旋转动画
val rotationAnimator = ObjectAnimator.ofFloat(iv_anim, "rotation", 0f, 180f, 270f, 90f)
// 平移动画
val transAnimator = ObjectAnimator.ofFloat(iv_anim, "translationX", 500f, -200f, 100f, 0f)
// 缩放动画
val scaleAnimator = ObjectAnimator.ofFloat(iv_anim, "scaleY", 0.2f, 2f)
// 自定义插值器与估值器
rotationAnimator.setEvaluator(MyFloatEvaluator())
rotationAnimator.interpolator = MyDecelerateInterpolator()
// 绑定点击事件
tv_object_alpha.setOnClickListener {
alphaAnimator.duration = 2000
alphaAnimator.start()
}
tv_object_rotate.setOnClickListener {
rotationAnimator.duration = 1600
rotationAnimator.start()
}
tv_object_scale.setOnClickListener {
scaleAnimator.duration = 2000
scaleAnimator.start()
}
tv_object_trans.setOnClickListener {
transAnimator.duration = 2000
transAnimator.start()
}
// 动画集合
tv_object_set.setOnClickListener {
AnimatorSet().apply {
play(alphaAnimator).with(transAnimator).with(scaleAnimator).after(rotationAnimator)
duration = 2000
start()
}
}
// 动画监听（完整）
alphaAnimator.addListener(object : Animator.AnimatorListener {
override fun onAnimationRepeat(animation: Animator?) {}
override fun onAnimationEnd(animation: Animator?) { Log.e(TAG, "onAnimationEnd: ") }
override fun onAnimationCancel(animation: Animator?) { Log.e(TAG, "onAnimationCancel: ") }
override fun onAnimationStart(animation: Animator?) { Log.e(TAG, "onAnimationStart: ") }
})
// 动画监听（简化版）
transAnimator.addListener(object : AnimatorListenerAdapter() {
override fun onAnimationEnd(animation: Animator?) {
super.onAnimationEnd(animation)
Log.e(TAG, "onAnimationEnd: ")
}
})
// 更新监听（每帧回调）
rotationAnimator.addUpdateListener {
Log.e(TAG, "onUpdate: ${it.animatedValue}")
}
// 从 XML 加载属性动画
tv_object_xml.setOnClickListener {
AnimatorInflater.loadAnimator(this, R.animator.demo).apply {
setTarget(iv_anim)
start()
}
}
iv_anim.setOnClickListener {
Log.e(TAG, "onClick: ")
}
}
override fun onBackPressed() {
super.onBackPressed()
overridePendingTransition(R.anim.act_back_enter, R.anim.act_back_exit)
}
}
MyDecelerateInterpolator.kt
package com.shakespace.artofandroid.chapter07anim
import android.util.Log
import android.view.animation.DecelerateInterpolator
import com.shakespace.firstlinecode.global.TAG
class MyDecelerateInterpolator : DecelerateInterpolator() {
override fun getInterpolation(input: Float): Float {
Log.e(TAG, "getInterpolation: ----$input ")
return super.getInterpolation(input)
}
}
MyFloatEvaluator.kt
package com.shakespace.artofandroid.chapter07anim
import android.animation.FloatEvaluator
import android.util.Log
import com.shakespace.firstlinecode.global.TAG
class MyFloatEvaluator : FloatEvaluator() {
override fun evaluate(fraction: Float, startValue: Number?, endValue: Number?): Float {
Log.e(TAG, "evaluate: fraction = $fraction startValue = $startValue endValue = $endValue")
return super.evaluate(fraction, startValue, endValue)
}
}
MyLinearInterpolator.kt
package com.shakespace.artofandroid.chapter07anim
import android.util.Log
import android.view.animation.LinearInterpolator
import com.shakespace.firstlinecode.global.TAG
class MyLinearInterpolator : LinearInterpolator() {
override fun getInterpolation(input: Float): Float {
Log.e(TAG, "getInterpolation: $input ")
return super.getInterpolation(input)
}
}
Rotate3DAnimation.kt
package com.shakespace.artofandroid.chapter07anim
import android.graphics.Camera
import android.view.animation.Animation
import android.view.animation.Transformation
/**
* 自定义 3D 旋转动画（围绕 Y 轴）
*/
class Rotate3DAnimation(
var fromDegree: Float,
val toDegree: Float,
val centerX: Float,
val centerY: Float,
val depthZ: Float,
val reverse: Boolean
) : Animation() {
var camera: Camera? = null
override fun applyTransformation(interpolatedTime: Float, t: Transformation?) {
val degrees = fromDegree + (toDegree - fromDegree) * interpolatedTime
val matrix = t?.matrix
camera?.apply {
save()
if (reverse) {
translate(0.0f, 0.0f, depthZ * interpolatedTime)
} else {
translate(0.0f, 0.0f, depthZ * (1.0f - interpolatedTime))
}
rotateY(degrees)
getMatrix(matrix)
restore()
matrix?.preTranslate(-centerX, -centerY)
matrix?.postTranslate(centerX, centerY)
}
}
override fun initialize(width: Int, height: Int, parentWidth: Int, parentHeight: Int) {
super.initialize(width, height, parentWidth, parentHeight)
camera = Camera()
}
}
三、文本笔记内容（原样保留）
z_memo_01viewAnim.txt
分类
1.View动画， 帧动画、属性动画
2.View动画
2.1 针对View
2.2 平移、缩放、旋转、透明度
2.3 对应4个类
TranslateAnimation
ScaleAnimation
RotateAnimation
AlphaAnimation
2.4 可以用代码创建，也可以用xml创建，建议使用xml，可读性好。
3. View动画 xml路径 -- res/anim/filename.xml
4. 代码中定义
// 以自身中心为参照
val rotate = RotateAnimation(
-90f,
270f,
RotateAnimation.RELATIVE_TO_SELF,
0.5f,
RotateAnimation.RELATIVE_TO_SELF,
0.5f
).apply {
duration = 1000
repeatCount = -1
repeatMode = Animation.REVERSE
}
tv_translation.setOnClickListener {
iv_anim.startAnimation(trans)
}
5. 使用xml中定义的动画
关键是 AnimationUtils.loadAnimation
tv_xml.setOnClickListener {
iv_anim.startAnimation(AnimationUtils.loadAnimation(this, R.anim.alpha))
}
6. 取消进行中的动画
view.clearAnimation()
Animation类的方法 解释
reset() 重置Animation的初始化
cancel() 取消Animation动画
start() 开始Animation动画
setAnimationListener() 给当前Animation设置动画监听
hasStarted() 判断当前Animation是否开始
hasEnded() 判断当前Animation是否结束
xml属性 java方法 解释
android:duration setDuration(long) 动画持续时间，毫秒为单位
android:ShareInterpolator setInterpolator(Interpolator) 设定插值器（指定的动画效果，譬如回弹等）
android:fillAfter setFillAfter(boolean) 控件动画结束时是否保持动画最后的状态
android:fillBefore setFillBefore(boolean) 控件动画结束时是否还原到开始动画前的状态
android:repeatMode setRepeatMode(int) 重复类型有两个值，reverse表示倒序回放，restart表示从头播放
android:startOffset setStartOffset(long) 调用start函数之后等待开始运行的时间，单位为毫秒
z_memo_02frameAnim.txt
分类
1.View动画， 帧动画、属性动画
2. 帧动画通过AnimationDrawable实现
3. 这是一个drawable，所以需要在drawable下创建资源
z_memo_03ElseApply.txt
1. 通过layoutAnimation 给ViewGroup加动画
参加 anim_layout.xml
2. 给Activity切换添加动画
overridePendingTransition(R.anim.act_enter,R.anim.act_exit)
第一个参数是给即将显示的Activity，后一个是当前。
3. 在fragmentTransaction中可以通过setCustomAnimations 设置fragment的进出场动画
4. 可以在主题中设置
<style name="AnimationActivity">
<item name="android:activityOpenEnterAnimation">@anim/alpha</item>
<item name="android:activityOpenExitAnimation">@anim/alpha</item>
<item name="android:activityCloseEnterAnimation">@anim/alpha</item>
<item name="android:activityCloseExitAnimation">@anim/alpha</item>
</style>
属性动画相比View动画存在一个缺陷，View动画改变的只是View的显示，而没有改变View的响应区域，并且View动画只能对View做四种类型的补间动画
z_memo_04propertyAnim.txt
View动画即补间动画
View动画存在一个缺陷，View动画改变的只是View的显示，而没有改变View的响应区域，并且View动画只能对View做四种类型的补间动画
补间动画只能进行简单动画，如果要执行一个颜色变化的动画，补间动画就做不到。
属性动画可以对任意对象进行动画，默认时间间隔300ms，帧率10ms/帧。
可以在一个时间间隔内完成一个属性值的变化。
常用的是ObjectAnimator， ValueAnimator，AnimatorSet
object是value的子类，更为常用。
它实际上是一种不断地对值进行操作的机制，并将值赋值到指定对象的指定属性上，可以是任意对象的任意属性。
属性动画定义在
res/animator下
补间动画
res/anim
1. 一般用法
val anim = ValueAnimator.ofFloat(0f, 1f)
anim.duration = 700
anim.interpolator = LinearInterpolator()
anim.addUpdateListener { animation ->
// 监听变化 执行操作
mPhaseY = animation.animatedValue as Float
invalidate()
}
anim.start()
valueAnimator的常用方法就是ValueAnimator.ofFloat 和 ofInt
1. 一个针对小数，一个针对整数。
2. 都可以传入多个值
3. 此外还有一个ofObject
2. xml
val animator = AnimatorInflater.loadAnimator(this, R.animator.demo)
animator.setTarget(iv_anim)
animator.start()
3. else
repeatCount : 循环次数，-1 （INFINITE） ，无限循环
repeatMode： repeat、reverse
4. 实际使用属性动画时一般使用代码完成的，因为很多属性值范围运行时才知道
5. 针对Color变化的动画，需要设置Argb估值器
z_memo_05Interpolator.txt
TimeInterpolator
是个接口，时间插值器。
作用是根据时间流逝的百分比计算当前属性改变的百分比。
Interpolator 继承于 TimeInterpolator
LinearInterpolator
AccelerateDecelerateInterpolator
DecelerateInterpolator
插值器的效果主要看
getInterpolation 的返回值。
LinearInterpolator
public float getInterpolation(float input) {
return input;
}
输入等于输出，也就是说，假如时间进行了20%，属性变化也应该是20%
AccelerateDecelerateInterpolator
public float getInterpolation(float input) {
return (float)(Math.cos((input + 1) * Math.PI) / 2.0f) + 0.5f;
}
使用了余弦函数。
正常来说，getInterpolation应该满足，输入0时，返回0，输入1时，返回1.
TypeEvaluator
估值器,作用是根据当前属性的百分比来计算改变后的属性值。
ArgbEvaluator （针对Color）
FloatEvaluator
IntEvaluator
IntEvaluator
public Integer evaluate(float fraction, Integer startValue, Integer endValue) {
int startInt = startValue;
return (int)(startInt + fraction * (endValue - startInt));
}
这里的fraction ，和上面getInterpolation的返回值有关【不一定相同】，根据这个值（比例），乘以起始和结束之差，再加上起始值，就得出当前值。
取值的间隔和屏幕刷新率有关，一般是16ms一次
属性动画可以有多个值，如果是线性插值器，每两个值之间的变化时间是相同的。
插值器的变化都是从0--1
估值器的fraction，如果属性有多段变化，就会有多次0---1的变化过程。
animator.getAnimatedFraction() 可以得到当前的fraction
在通过估值器获取值
fraction = mInterpolator.getInterpolation(fraction);?
E/MyLinearInterpolator: getInterpolation: 0.0168
E/MyFloatEvaluator: evaluate: fraction = 0.0168 startValue = 0.0 endValue = 360.0
z_memo_06Else.txt
Q: 如何对一个button的width做动画
1. 补间动画做不到，因为补间动画只能做伸缩平移等操作，无法针对width操作
2. 属性动画无法直接做到
ObjectAnimator.ofInt(tv_demo,"width", tv_demo.dp2px(200f),tv_demo.dp2px(600f)).start()
没有效果。
3. 属性动画要有效果需要两个条件
例如；width属性
1. 对象有setWidth这个方法 （如果没有，程序会Crash）
2. width属性的改变能够通过某种方式显示出来，体现在UI上，否则看上去没效果。
所以：
button虽然有setWidth方法（是用来设置最大和最小宽度的），但是set的width和button的宽度不是同一个东西，因为没有效果可以展示出来。
4. 解决方案
1. 给这个属性加上get、set方法 (不适用，或者需要自定义继承button)
2. 用一个类包装view 【常用】
inner class ViewWrapper(private val view: View) {
fun getWidth(): Int {
return view.layoutParams.width
}
fun setWidth(width: Int) {
view.layoutParams.width = width
view.requestLayout()
}
}
3. 使用ValueAnimator ， 结合UpdateListener
z_memo_07Flow.txt
ObjectAnimator.ofInt(ViewWrapper(tv_demo), "width", tv_demo.dp2px(100f), tv_demo.dp2px(300f)).start()
public static ObjectAnimator ofInt(Object target, String propertyName, int... values) {
ObjectAnimator anim = new ObjectAnimator(target, propertyName);
anim.setIntValues(values);
return anim;
}
// 设置对象和属性集合
private ObjectAnimator(Object target, String propertyName) {
setTarget(target);
setPropertyName(propertyName);
}
public void setTarget(@Nullable Object target) {
final Object oldTarget = getTarget();
if (oldTarget != target) {
if (isStarted()) {
cancel();
}
mTarget = target == null ? null : new WeakReference<Object>(target);
// New target should cause re-initialization prior to starting
mInitialized = false;
}
}
public void setPropertyName(@NonNull String propertyName) {
// mValues could be null if this is being constructed piecemeal. Just record the
// propertyName to be used later when setValues() is called if so.
if (mValues != null) {
PropertyValuesHolder valuesHolder = mValues[0];
String oldName = valuesHolder.getPropertyName();
valuesHolder.setPropertyName(propertyName);
mValuesMap.remove(oldName);
mValuesMap.put(propertyName, valuesHolder);
}
mPropertyName = propertyName;
// New property/values/target should cause re-initialization prior to starting
mInitialized = false;
}
@Override
public void setIntValues(int... values) {
if (mValues == null || mValues.length == 0) {
// No values yet - this animator is being constructed piecemeal. Init the values with
// whatever the current propertyName is
if (mProperty != null) {
setValues(PropertyValuesHolder.ofInt(mProperty, values));
} else {
setValues(PropertyValuesHolder.ofInt(mPropertyName, values));
}
} else {
super.setIntValues(values);
}
}
mValues 在ValueAnimator中定义，一开始为null
使用propertyName的方式，property一开为null
执行 setValues(PropertyValuesHolder.ofInt(mPropertyName, values));
public void setValues(PropertyValuesHolder... values) {
int numValues = values.length;
mValues = values;
mValuesMap = new HashMap<String, PropertyValuesHolder>(numValues);
for (int i = 0; i < numValues; ++i) {
PropertyValuesHolder valuesHolder = values[i];
mValuesMap.put(valuesHolder.getPropertyName(), valuesHolder);
}
// New property/values/target should cause re-initialization prior to starting
mInitialized = false;
}
// 准备完成
start()
@Override
public void start() {
AnimationHandler.getInstance().autoCancelBasedOn(this);
//.... 取消当前的动画，调用super
super.start();
}
private void start(boolean playBackwards) {
if (Looper.myLooper() == null) {
throw new AndroidRuntimeException("Animators may only be run on Looper threads");
}
mReversing = playBackwards;
mSelfPulse = !mSuppressSelfPulseRequested;
// Special case: reversing from seek-to-0 should act as if not seeked at all.
if (playBackwards && mSeekFraction != -1 && mSeekFraction != 0) {
if (mRepeatCount == INFINITE) {
// Calculate the fraction of the current iteration.
float fraction = (float) (mSeekFraction - Math.floor(mSeekFraction));
mSeekFraction = 1 - fraction;
} else {
mSeekFraction = 1 + mRepeatCount - mSeekFraction;
}
}
mStarted = true;
mPaused = false;
mRunning = false;
mAnimationEndRequested = false;
// Resets mLastFrameTime when start() is called, so that if the animation was running,
// calling start() would put the animation in the
// started-but-not-yet-reached-the-first-frame phase.
mLastFrameTime = -1;
mFirstFrameTime = -1;
mStartTime = -1;
addAnimationCallback(0);
if (mStartDelay == 0 || mSeekFraction >= 0 || mReversing) {
// If there's no start delay, init the animation and notify start listeners right away
// to be consistent with the previous behavior. Otherwise, postpone this until the first
// frame after the start delay.
startAnimation();
if (mSeekFraction == -1) {
// No seek, start at play time 0. Note that the reason we are not using fraction 0
// is because for animations with 0 duration, we want to be consistent with pre-N
// behavior: skip to the final value immediately.
setCurrentPlayTime(0);
} else {
setCurrentFraction(mSeekFraction);// 关键
}
}
}
public void setCurrentFraction(float fraction) {
initAnimation();
fraction = clampFraction(fraction);
mStartTimeCommitted = true; // do not allow start time to be compensated for jank
if (isPulsingInternal()) {
long seekTime = (long) (getScaledDuration() * fraction);
long currentTime = AnimationUtils.currentAnimationTimeMillis();
// Only modify the start time when the animation is running. Seek fraction will ensure
// non-running animations skip to the correct start time.
mStartTime = currentTime - seekTime;
} else {
// If the animation loop hasn't started, or during start delay, the startTime will be
// adjusted once the delay has passed based on seek fraction.
mSeekFraction = fraction;
}
mOverallFraction = fraction;
final float currentIterationFraction = getCurrentIterationFraction(fraction, mReversing);
animateValue(currentIterationFraction);
}
// 执行动画
void animateValue(float fraction) {
fraction = mInterpolator.getInterpolation(fraction);
mCurrentFraction = fraction;
int numValues = mValues.length;
for (int i = 0; i < numValues; ++i) {
mValues[i].calculateValue(fraction);
}
if (mUpdateListeners != null) {
int numListeners = mUpdateListeners.size();
for (int i = 0; i < numListeners; ++i) {
mUpdateListeners.get(i).onAnimationUpdate(this);
}
}
}
// 在ObjectAnimator中重写了
void animateValue(float fraction) {
final Object target = getTarget();
if (mTarget != null && target == null) {
// We lost the target reference, cancel and clean up. Note: we allow null target if the
/// target has never been set.
cancel();
return;
}
super.animateValue(fraction);
int numValues = mValues.length;
for (int i = 0; i < numValues; ++i) {
mValues[i].setAnimatedValue(target);
}
}
// mValues[i].setAnimatedValue(target); 反射调用 属性的set方法
void setAnimatedValue(Object target) {
if (mProperty != null) {
mProperty.set(target, getAnimatedValue());
}
if (mSetter != null) {
try {
mTmpValueArray[0] = getAnimatedValue();
mSetter.invoke(target, mTmpValueArray);
} catch (InvocationTargetException e) {
Log.e("PropertyValuesHolder", e.toString());
} catch (IllegalAccessException e) {
Log.e("PropertyValuesHolder", e.toString());
}
}
}
@Override
void calculateValue(float fraction) {
mIntAnimatedValue = mIntKeyframes.getIntValue(fraction);
}
//PropertyValuesHolder
void setupSetterAndGetter(Object target) {
if (mProperty != null) {
// check to make sure that mProperty is on the class of target
try {
Object testValue = null;
List<Keyframe> keyframes = mKeyframes.getKeyframes();
int keyframeCount = keyframes == null ? 0 : keyframes.size();
for (int i = 0; i < keyframeCount; i++) {
Keyframe kf = keyframes.get(i);
if (!kf.hasValue() || kf.valueWasSetOnStart()) {
if (testValue == null) {
testValue = convertBack(mProperty.get(target));
}
kf.setValue(testValue);
kf.setValueWasSetOnStart(true);
}
}
return;
} catch (ClassCastException e) {
Log.w("PropertyValuesHolder","No such property (" + mProperty.getName() +
") on target object " + target + ". Trying reflection instead");
mProperty = null;
}
}
// We can't just say 'else' here because the catch statement sets mProperty to null.
if (mProperty == null) {
Class targetClass = target.getClass();
if (mSetter == null) {
setupSetter(targetClass);
}
List<Keyframe> keyframes = mKeyframes.getKeyframes();
int keyframeCount = keyframes == null ? 0 : keyframes.size();
for (int i = 0; i < keyframeCount; i++) {
Keyframe kf = keyframes.get(i);
if (!kf.hasValue() || kf.valueWasSetOnStart()) {
if (mGetter == null) {
setupGetter(targetClass);
if (mGetter == null) {
// Already logged the error - just return to avoid NPE
return;
}
}
try {
Object value = convertBack(mGetter.invoke(target));
kf.setValue(value);
kf.setValueWasSetOnStart(true);
} catch (InvocationTargetException e) {
Log.e("PropertyValuesHolder", e.toString());
} catch (IllegalAccessException e) {
Log.e("PropertyValuesHolder", e.toString());
}
}
}
}
}
@CallSuper注解主要是用来强调在覆盖父类方法的时候，需要实现父类的方法，及时调用对应的super.**方法，当使用 @CallSuper 修饰了某个方法，
如果子类覆盖父类该方法后没有实现对父类方法的调用就会报错
@CallSuper
void initAnimation() {
if (!mInitialized) {
int numValues = mValues.length;
for (int i = 0; i < numValues; ++i) {
mValues[i].init();
}
mInitialized = true;
}
}
z_memo_08note.txt
1. 帧动画容易引起oom，尽量避免使用
2. 在activity结束时要及时结束动画，避免内存泄漏
3. view动画有时候会出现setVisibility(View.GONE)无效的情况，需要先clearAnimation，再设置
4. 建议开启硬件加速
浙公网安备 33010602011771号