huansky资料

本文主要介绍huansky资料 方法和在新技术下所面对的“挑战”,方便大家深入理解huansky资料 过程。本文也将分享huansky资料 所遇到的问题和应对策略,怎么解决怎么做的问题。
通过深入本文可以理解代码原理,进行代码文档的下载,也可以查看相应 Demo 部署效果。

Android 平台目前提供了两大类动画,在 Android 3.0 之前,一大类是 View Animation,包括 Tween animation(补间动画),Frame animation(帧动画),在 Android 3.0 中又引入了一个新的动画系统:Property Animation,即属性动画。本篇文章主要介绍 View Animation 的运行原理。

View Animation 可以使视图执行补间动画。即给定两个关键帧,然后中间部分按照一定的算法自动计算补充。

补间动画的继承关系:

 huansky

下面看一个示例,比如想要对透明度做一个变化:

Animation alphaAnimation = new AlphaAnimation(1,0); alphaAnimation.setDuration(1000); imageView.startAnimation(alphaAnimation);

huansky

 

 那么这个动画是如何实现的呢,下面就要讲述其实现原理。 

为了探究补间动画的实现原理,需要对相关源码进行解读,源码版本为 Android API 29 Platform。在解读之前,大家可以试着回答下面这些问题。

  1. 为什么移动位置后,点击事件的响应依旧是在原来位置上?

  2. 如果想知道动画的执行进度,是如何获取呢?

  3. 如果对 View 做放大缩小得动画,那么其宽度高度值是否会变化。

相关类介绍

下面开始源码分析。首先看下基类 Animation。

public abstract class Animation implements Cloneable {  }

Animation 是一个抽象类,里面包含了各种动画相关的属性(时长,起始时间,重复次数,插值器等),回调(listeners)。该类整体比较简单,大家直接看源码就好。

alphaAnimation

下面来看下 Animation 子类,为了方便,本次就只说说 AlphaAnimation。

public class AlphaAnimation extends Animation {     private float mFromAlpha;     private float mToAlpha;      /**      * Constructor used when an AlphaAnimation is loaded from a resource.       *       * @param context Application context to use      * @param attrs Attribute set from which to read values      */     public AlphaAnimation(Context context, AttributeSet attrs) {         super(context, attrs);                  TypedArray a =             context.obtainStyledAttributes(attrs, com.android.internal.R.styleable.AlphaAnimation);                  mFromAlpha = a.getFloat(com.android.internal.R.styleable.AlphaAnimation_fromAlpha, 1.0f);         mToAlpha = a.getFloat(com.android.internal.R.styleable.AlphaAnimation_toAlpha, 1.0f);                  a.recycle();     }          /**      * Constructor to use when building an AlphaAnimation from code      *       * @param fromAlpha Starting alpha value for the animation, where 1.0 means      *        fully opaque and 0.0 means fully transparent.      * @param toAlpha Ending alpha value for the animation.      */     public AlphaAnimation(float fromAlpha, float toAlpha) {         mFromAlpha = fromAlpha;         mToAlpha = toAlpha;     }          /**      * Changes the alpha property of the supplied {@link Transformation} 
   * 实现动画的关键函数,这里通过当前的播放进度,计算当前的透明度,然后将其赋值给 Transformation 实例
*/ @Override protected void applyTransformation(float interpolatedTime, Transformation t) { final float alpha = mFromAlpha; t.setAlpha(alpha + ((mToAlpha - alpha) * interpolatedTime)); } @Override public boolean willChangeTransformationMatrix() { return false; } @Override // 不改变边界 public boolean willChangeBounds() { return false; } /** * @hide */ @Override public boolean hasAlpha() { return true; } }

整个代码也是很简单,其实很多逻辑都在基类处理了。然后子类只需要重写一些和自己动画相关的方法就好。其中 applyTransformation 是实现某一种动画的关键,每个子类都必须重写。

这里需要注意的是,Transformation 就是用来存储每一次动画的参数。其中平移,旋转,缩放都是通过改变 Matrix 实现的,而透明度则是改变 Alpha 值实现的。

为了便于大家进一步理解,可以在看看 AnimationSet。

AnimationSet

因为 AnimationSet 是其他几个子类得集合体,所以看看它的代码逻辑还是可以发现一些不一样的。其内部代码比较多,就不贴出来了。只是挑一部分讲下:

    /**      * Add a child animation to this animation set.      * The transforms of the child animations are applied in the order      * that they were added      * @param a Animation to add.      */     public void addAnimation(Animation a) {
     // 数组来保存动画 mAnimations.add(a);
boolean noMatrix = (mFlags & PROPERTY_MORPH_MATRIX_MASK) == 0; if (noMatrix && a.willChangeTransformationMatrix()) { mFlags |= PROPERTY_MORPH_MATRIX_MASK; } boolean changeBounds = (mFlags & PROPERTY_CHANGE_BOUNDS_MASK) == 0; if (changeBounds && a.willChangeBounds()) { mFlags |= PROPERTY_CHANGE_BOUNDS_MASK; } if ((mFlags & PROPERTY_DURATION_MASK) == PROPERTY_DURATION_MASK) { mLastEnd = mStartOffset + mDuration; } else { if (mAnimations.size() == 1) { mDuration = a.getStartOffset() + a.getDuration(); mLastEnd = mStartOffset + mDuration; } else { mLastEnd = Math.max(mLastEnd, mStartOffset + a.getStartOffset() + a.getDuration()); mDuration = mLastEnd - mStartOffset; } } mDirty = true; } /** * The transformation of an animation set is the concatenation of all of its * component animations. * * @see android.view.animation.Animation#getTransformation
   * true 表示动画还在运行
*/ @Override public boolean getTransformation(long currentTime, Transformation t) { final int count = mAnimations.size(); final ArrayList<Animation> animations = mAnimations; final Transformation temp = mTempTransformation; boolean more = false; boolean started = false; boolean ended = true; t.clear(); for (int i = count - 1; i >= 0; --i) { final Animation a = animations.get(i);        // 清除上一个的数据 temp.clear();
       // 通过 temp 来获取每个 Animation 的 transformation more
= a.getTransformation(currentTime, temp, getScaleFactor()) || more;
       // 将各种动画参数组合在一起,注意 t 是引用对象,所以这里改了之后,外面拿到的也是改了的。 t.compose(temp); started
= started || a.hasStarted(); ended = a.hasEnded() && ended; }      // 是否开始了 if (started && !mStarted) { dispatchAnimationStart(); mStarted = true; } if (ended != mEnded) { dispatchAnimationEnd(); mEnded = ended; } return more; }

上面是 AnimationSet 中我认为两个比较重要的方法:

  • addAnimation:将其他动画类型添加到 set 里面,内部实际上是通过一个 list 来保存的。然后将每个动画的各种属性都记录下。

  • getTransformation:获取每个动画的下一个动画参数,然后将其组合在一起。

前面介绍了 Animation 一些背景知识。到这里,大家多少会有一些认识了。接下去就按照调用流程来分析动画的执行。

源码解析

View.startAnimation()

    public void startAnimation(Animation animation) {
     // 传入的值是-1,代表准备动画了 animation.setStartTime(Animation.START_ON_FIRST_FRAME); setAnimation(animation); invalidateParentCaches(); // 给 parent 的 mPrivateFlag 加了一个 PFLAG_INVALIDATED invalidate(
true); // 其目的就是将其和子 view 的 drawing 缓存都标记为无效,然后可以 redrawn } public void setAnimation(Animation animation) {
     // View 中有个属性是用来存储当前的 Animation 的 mCurrentAnimation
= animation; if (animation != null) { // If the screen is off assume the animation start time is now instead of // the next frame we draw. Keeping the START_ON_FIRST_FRAME start time // would cause the animation to start when the screen turns back on if (mAttachInfo != null && mAttachInfo.mDisplayState == Display.STATE_OFF && animation.getStartTime() == Animation.START_ON_FIRST_FRAME) { animation.setStartTime(AnimationUtils.currentAnimationTimeMillis()); } animation.reset(); } }

 简而言之 startAnimation 主要是做这么几件事情:

  1. 开始动画前,先告知 Animation,可以做一些准备,包括部分参数的赋值;

  2. 更新 View 自身的 Animation 的属性值;

  3. 给父 View 的 mPrivateFlag 加上 PFLAG_INVALIDATED 属性;

  4. 将自身和子 view 的 draw cache 都标记为无效的,通过 父 View 调用 invalidateChild 促发 redrawn;

ViewGroup.invalidateChild

下面看下 invalidateChild 是怎么促发重绘的:

// ViewGroup      public final void invalidateChild(View child, final Rect dirty) {         final AttachInfo attachInfo = mAttachInfo;         if (attachInfo != null && attachInfo.mHardwareAccelerated) {             // HW accelerated fast path             onDescendantInvalidated(child, child);             return;         }          ViewParent parent = this;         if (attachInfo != null) {            //  ..... 省略非关键性代码               do { // 无限循环                 View view = null;                 if (parent instanceof View) {                     view = (View) parent;                 }                  if (drawAnimation) {                     if (view != null) {                         view.mPrivateFlags |= PFLAG_DRAW_ANIMATION;                     } else if (parent instanceof ViewRootImpl) {                         ((ViewRootImpl) parent).mIsAnimating = true;                     }                 }                  // If the parent is dirty opaque or not dirty, mark it dirty with the opaque                 // flag coming from the child that initiated the invalidate                 if (view != null) {                     if ((view.mPrivateFlags & PFLAG_DIRTY_MASK) != PFLAG_DIRTY) {                         view.mPrivateFlags = (view.mPrivateFlags & ~PFLAG_DIRTY_MASK) | PFLAG_DIRTY;                     }                 }           // 最终调用的是该方法来重绘                 parent = parent.invalidateChildInParent(location, dirty);                 //  .... 省略非关键性代码              } while (parent != null);  // 终止条件是找不到父 View 了。         }     }

这里很主要的一件事,找到 rooView ,然后调用了 invalidateChildInParent 方法。这里的 rootView 其实就是 ViewRootImpl,至于为啥不是 DecorVIew,这个可以去看看这篇文章:

Android View 绘制流程之 DecorView 与 ViewRootImpl

ViewRootImpl.invalidateChildInParent

    @Override     public ViewParent invalidateChildInParent(int[] location, Rect dirty) {         checkThread();  // 检查是否是主线程         if (DEBUG_DRAW) Log.v(mTag, "Invalidate child: " + dirty);          if (dirty == null) {  // 从上面路径来看,这里是不可能为空的             invalidate();               return null;         } else if (dirty.isEmpty() && !mIsAnimating) {             return null;         }          // ... 跳过一段无关的代码
invalidateRectOnScreen(dirty); return null; }

这里可以看出的是,最终会调用 invalidateRectOnScreen 方法。

ViewRootImpl.invalidateRectOnScreen

    private void invalidateRectOnScreen(Rect dirty) {         final Rect localDirty = mDirty;          // Add the new dirty rect to the current one 其实就是把两个矩阵融合在一起         localDirty.union(dirty.left, dirty.top, dirty.right, dirty.bottom);         // Intersect with the bounds of the window to skip         // updates that lie outside of the visible region         final float appScale = mAttachInfo.mApplicationScale;
     // 主要就是检查菊矩阵边界对不对
final boolean intersected = localDirty.intersect(0, 0, (int) (mWidth * appScale + 0.5f), (int) (mHeight * appScale + 0.5f));
     // 边界不对,就会直接置空
if (!intersected) { localDirty.setEmpty(); }
     // mWillDrawSoon 是当前是否马上就要开始绘制了,如果开始绘制,就不去发起绘制了
if (!mWillDrawSoon && (intersected || mIsAnimating)) { scheduleTraversals(); } }

 invalidateRectOnScreen 主要是就是把 dirty 这个矩阵和已有的进行融合,然后再看看需不需要发起刷新。

scheduleTraversals() 作用是将 performTraversals() 封装到一个 Runnable 里面,然后扔到 Choreographer 的待执行队列里,这些待执行的 Runnable 将会在最近的一个 16.6 ms 屏幕刷新信号到来的时候被执行。而 performTraversals() 是 View 的三大操作:测量、布局、绘制的发起者。

小结:

当调用了 View.startAniamtion() 之后,动画并没有马上就被执行,这个方法只是做了一些变量初始化操作,接着将 View 和 Animation 绑定起来,然后调用重绘请求操作,内部层层寻找 mParent,最终走到 ViewRootImpl 的 scheduleTraversals 里发起一个遍历 View 树的请求,这个请求会在最近的一个屏幕刷新信号到来的时候被执行,调用 performTraversals 从根布局 DecorView 开始遍历 View 树。

开始动画

前面说到了动画的开始最终是通过促发 View 绘制来形成的。此处不会再讲 View 的绘制原理,不懂得可以看下面两篇文章:

  • Android View 的绘制流程之 Measure 过程详解 (一)

  • Android View 的绘制流程之 Layout 和 Draw 过程详解 (二)

那么在 View  绘制过程中,是在哪里开始绘制的呢? 答案是 View 的 draw 方法里面开始的。

但是这个 draw 不是我们自定义 view 时常见的 draw 方法,该 draw 方法有三个参数,是用于 View 自身绘制用的。

View.draw

该方法比较长,截取部分来讲:

/**      * This method is called by ViewGroup.drawChild() to have each child view draw itself.      *      * This is where the View specializes rendering behavior based on layer type,      * and hardware acceleration.      */     boolean draw(Canvas canvas, ViewGroup parent, long drawingTime) {
     // 用于判断是否支持硬件加速
final boolean hardwareAcceleratedCanvas = canvas.isHardwareAccelerated(); /* If an attached view draws to a HW canvas, it may use its RenderNode + DisplayList. * * If a view is dettached, its DisplayList shouldn't exist. If the canvas isn't * HW accelerated, it can't handle drawing RenderNodes. */ boolean drawingWithRenderNode = mAttachInfo != null && mAttachInfo.mHardwareAccelerated && hardwareAcceleratedCanvas; boolean more = false; // ..... 跳过一些代码

     // 获取之前存储的 animation      final Animation a = getAnimation(); if (a != null) {
       // 不为空就说明是有动画的 more
= applyLegacyAnimation(parent, drawingTime, a, scalingRequired); concatMatrix = a.willChangeTransformationMatrix(); if (concatMatrix) { mPrivateFlags3 |= PFLAG3_VIEW_IS_ANIMATING_TRANSFORM; }
       // 这里是拿到动画参数,后面会再次讲到 transformToApply
= parent.getChildTransformation(); } // ...... 省略代码 }

首先来看这个 draw 方法的三个参数:

  1. canvas:这个没有什么好分析的,是用来绘制用的

  2. parent:这个其实就是父 View,方便获取一些数据;

  3. drawingTime:这个很重要,就是当前的绘制时间,后续做动画的时候,会计算时间差,然后更新插值器;

一进到 draw 方法,就先获取当前是否支持硬件加速。有硬件加速和没有硬件加速走的是两套逻辑。然后是获取保之前存储的 animation。

View.applyLegacyAnimation

接着调用 applyLegacyAnimation 开始处理动画相关的逻辑。下面看下其方法内部的逻辑。

    /**      * Utility function, called by draw(canvas, parent, drawingTime) to handle the less common      * case of an active Animation being run on the view.      */     private boolean applyLegacyAnimation(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(); }      // 这里是从父类中获取当前的t,但是如果一个父类存在多个子 view 需要运动,那获取的岂不是一样了?其实每个子view 都会重新赋值,不会影响。
final Transformation t = parent.getChildTransformation();
     // 这里是根据时间,t, 缩放因子来计算 t,这里 t 是一个对象,在 animation 中进行赋值后,在这里也可以用到
boolean more = a.getTransformation(drawingTime, t, 1f);
     // 对于需要缩放的子view,需要重新计算t,可是调用方法确是一样的?那结果有啥不一样吗?这里是为了将缩放和不缩放的 t 分出来
if (scalingRequired && mAttachInfo.mApplicationScale != 1f) { if (parent.mInvalidationTransformation == null) { parent.mInvalidationTransformation = new Transformation(); } invalidationTransform = parent.mInvalidationTransformation; a.getTransformation(drawingTime, invalidationTransform, 1f); } else { invalidationTransform = t; }      // more 为 true ,代表动画还未结束 if (more) { if (!a.willChangeBounds()) { if ((flags & (ViewGroup.FLAG_OPTIMIZE_INVALIDATE | ViewGroup.FLAG_ANIMATION_DONE)) == ViewGroup.FLAG_OPTIMIZE_INVALIDATE) { parent.mGroupFlags |= ViewGroup.FLAG_INVALIDATE_REQUIRED; } else if ((flags & ViewGroup.FLAG_INVALIDATE_REQUIRED) == 0) { // The child need to draw an animation, potentially offscreen, so // make sure we do not cancel invalidate requests parent.mPrivateFlags |= PFLAG_DRAW_ANIMATION;
            // 发起下一次重绘 parent.invalidate(mLeft, mTop, mRight, mBottom); } }
else { if (parent.mInvalidateRegion == null) { parent.mInvalidateRegion = new RectF(); } final RectF region = parent.mInvalidateRegion;
          // 对于会改变自己边界的动画,比如缩放,这时候需要计算当前缩放的尺寸范围 a.getInvalidateRegion(
0, 0, mRight - mLeft, mBottom - mTop, region, invalidationTransform); // The child need to draw an animation, potentially offscreen, so // make sure we do not cancel invalidate requests parent.mPrivateFlags |= PFLAG_DRAW_ANIMATION;           // region 此时是更新尺寸后的范围了 final int left = mLeft + (int) region.left; final int top = mTop + (int) region.top;
         // 发起下一次重绘 parent.invalidate(left, top, left
+ (int) (region.width() + .5f), top + (int) (region.height() + .5f)); } } return more; }

这个方法其实理解起来也很简单,主要就是为了得到一个根据当前时间计算得到 Transformation 实例,里面包含了下一次动画所需要的信息。

Transformation 里面的内容如下:

Transformation

public class Transformation {     /**      * Indicates a transformation that has no effect (alpha = 1 and identity matrix.)      */     public static final int TYPE_IDENTITY = 0x0;     /**      * Indicates a transformation that applies an alpha only (uses an identity matrix.)      */     public static final int TYPE_ALPHA = 0x1;     /**      * Indicates a transformation that applies a matrix only (alpha = 1.)      */     public static final int TYPE_MATRIX = 0x2;     /**      * Indicates a transformation that applies an alpha and a matrix.      */     public static final int TYPE_BOTH = TYPE_ALPHA | TYPE_MATRIX;    // 矩阵,控制缩放,平移,旋转     protected Matrix mMatrix;
   // 透明度
protected float mAlpha; protected int mTransformationType; private boolean mHasClipRect; private Rect mClipRect = new Rect(); // ...... 省略一大串代码 }

 

上述代码还省略很多方法,其实都是对矩阵的操作。

这里提一下:Matrix 方法中的 setRotate() 方法会先清除该矩阵,即设为单位矩阵。之后设置旋转操作的,同样,setTranslate() 等方法也是一样的。所以是不能叠加各种效果在一起的.如果是想多种效果同时使用的话,postRotate(),postTranslate()等类似的矩阵变换方法吧。

想进一步了解的可直接阅读代码。

下面讲下是如何获取 Transformation 的。

Animation.getTransformation

    public boolean getTransformation(long currentTime, Transformation outTransformation) {
     // 等于-1,说明是刚开始动画,记录第一帧动画时间
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 || isCanceled(); mMore = !expired;      // 确保动画在 0-1 之间 if (!mFillEnabled) normalizedTime = Math.max(Math.min(normalizedTime, 1.0f), 0.0f); if ((normalizedTime >= 0.0f || mFillBefore) && (normalizedTime <= 1.0f || mFillAfter)) { if (!mStarted) {
          // 通知动画开始了。onAnimationStart 就是在这里被调用 fireAnimationStart(); mStarted
= true; if (NoImagePreloadHolder.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);
       // 这里 out 前缀就是这个是要传出去的,这个方法每个 Animation 子类都要自己实现,然后其实我们可以重写这个方法,把进度传出去你就知道当前动画的进度了 applyTransformation(interpolatedTime, outTransformation); }      // 如果动画被取消或者已经完成了
if (expired) { if (mRepeatCount == mRepeated || isCanceled()) { if (!mEnded) { mEnded = true; guard.close();
            // 这里就是 onAnimationEnd 调用的地方 fireAnimationEnd(); } }
else {
          // else 说明动画是重复的,这是需要计算重复次数,还有是不是无限循环的
if (mRepeatCount > 0) { mRepeated++; } if (mRepeatMode == REVERSE) { mCycleFlip = !mCycleFlip; } mStartTime = -1; mMore = true;           // 这里就是 onAnimationRepeat 调用的地方 fireAnimationRepeat(); } } if (!mMore && mOneMoreTime) { mOneMoreTime = false; return true; } return mMore; }

 

getTransformation 主要就是管理动画状态的。到底是开始(记录开始时间),还是正在进行(计算进度),还是已经结束了(通知结束了)。

其中调用的 applyTransformation,每个 Animation 子类都要自己实现,然后其实我们可以重写这个方法,把进度传出去你就知道当前动画的进度了。子类其实是把最后的计算结果保存在 Transformation 里面了,这样就拿到了下一帧动画参数。

还有大家平时用到的 AnimationListener 也是在这里进行通知回调的。

那拿到 Transformation 后,是怎么用的呢,这个就得 回到 view.draw 方法了。

view.draw

前面讲到了 Transformation 其实是从 parent 中获取,赋值给 transformToApply;

    boolean draw(Canvas canvas, ViewGroup parent, long drawingTime) {             // ...... 省略一大部分代码         float alpha = drawingWithRenderNode ? 1 : (getAlpha() * getTransitionAlpha());
     // 下面这个if 会进入动画的真正的绘制时期
if (transformToApply != null || alpha < 1 || !hasIdentityMatrix() || (mPrivateFlags3 & PFLAG3_VIEW_IS_ANIMATING_ALPHA) != 0) { if (transformToApply != null || !childHasIdentityMatrix) { int transX = 0; int transY = 0; if (offsetForScroll) { transX = -sx; transY = -sy; } if (transformToApply != null) { if (concatMatrix) {
               // 为TRUE,代表是使用硬件加速来进行绘制
if (drawingWithRenderNode) { renderNode.setAnimationMatrix(transformToApply.getMatrix()); } else { // Undo the scroll translation, apply the transformation matrix, // then redo the scroll translate to get the correct result. canvas.translate(-transX, -transY); canvas.concat(transformToApply.getMatrix()); canvas.translate(transX, transY); } parent.mGroupFlags |= ViewGroup.FLAG_CLEAR_TRANSFORMATION; } float transformAlpha = transformToApply.getAlpha();
            // 下面是关于透明度的动画
if (transformAlpha < 1) { alpha *= transformAlpha; parent.mGroupFlags |= ViewGroup.FLAG_CLEAR_TRANSFORMATION; } } if (!childHasIdentityMatrix && !drawingWithRenderNode) { canvas.translate(-transX, -transY); canvas.concat(getMatrix()); canvas.translate(transX, transY); } } // Deal with alpha if it is or used to be <1 if (alpha < 1 || (mPrivateFlags3 & PFLAG3_VIEW_IS_ANIMATING_ALPHA) != 0) { if (alpha < 1) { mPrivateFlags3 |= PFLAG3_VIEW_IS_ANIMATING_ALPHA; } else { mPrivateFlags3 &= ~PFLAG3_VIEW_IS_ANIMATING_ALPHA; } parent.mGroupFlags |= ViewGroup.FLAG_CLEAR_TRANSFORMATION; if (!drawingWithDrawingCache) { final int multipliedAlpha = (int) (255 * alpha); if (!onSetAlpha(multipliedAlpha)) { if (drawingWithRenderNode) { renderNode.setAlpha(alpha * getAlpha() * getTransitionAlpha()); } else if (layerType == LAYER_TYPE_NONE) { canvas.saveLayerAlpha(sx, sy, sx + getWidth(), sy + getHeight(), multipliedAlpha); } } else { // Alpha is handled by the child directly, clobber the layer's alpha mPrivateFlags |= PFLAG_ALPHA_SET; } } } } else if ((mPrivateFlags & PFLAG_ALPHA_SET) == PFLAG_ALPHA_SET) { onSetAlpha(255); mPrivateFlags &= ~PFLAG_ALPHA_SET; }

那么对于 AnimationSet 又是如何处理的呢?

首先他也是继承了了 Animation,其次,它有个数组装门用来存放 Animation 集合。也是通过  getTransformation 来获取Transformation的。

AnimationSet.

    public boolean getTransformation(long currentTime, Transformation t) {         final int count = mAnimations.size();         final ArrayList<Animation> animations = mAnimations;         final Transformation temp = mTempTransformation;          boolean more = false;         boolean started = false;         boolean ended = true;          t.clear();          for (int i = count - 1; i >= 0; --i) {             final Animation a = animations.get(i);              temp.clear();             more = a.getTransformation(currentTime, temp, getScaleFactor()) || more;             t.compose(temp);              started = started || a.hasStarted();             ended = a.hasEnded() && ended;         }          if (started && !mStarted) {             dispatchAnimationStart();             mStarted = true;         }          if (ended != mEnded) {             dispatchAnimationEnd();             mEnded = ended;         }          return more;     }

通过 for 循环,依次获取对应的 annimation 的矩阵,然后再将矩阵效果合到一起。

到此,对于 动画应该是有自己的认识了。 View Animation 的整个执行逻辑也就讲完了。

 

总结

那么这里回答开头的三个问题:

  • 为什么移动位置后,点击事件的响应依旧是在原来位置上?

因为动画是在 draw 时候形成的,也就是说只是视觉效果。其并没有改变它本身在父类中的位置;

  • 如果想知道动画的执行进度,是如何获取呢?

继承 Animation 对应的子类,然后重写 applyTransformation 方法,就可以从中获取到进度。

  • 如果对 View 做放大缩小得动画,那么其宽度高度值是否会变化。

动画发生在 draw 时期,并不会改变测量结果

 

View Animation 是在绘制的时候,改变 view 的视觉效果来实现动画的。所以不会对 view 的测量和布局过程有影响。

View 的动画是通过触发绘制过程来执行 draw 的。因为动画是连续的,所以需要不停的触发。

 

 

参考文章:

View 动画 Animation 运行原理解析

 

 

huansky资料部分资料来自网络,侵权毕设源码联系删除

区块链毕设网(www.qklbishe.com)全网最靠谱的原创区块链毕设代做网站
部分资料来自网络,侵权联系删除!
资源收费仅为搬运整理打赏费用,用户自愿支付 !
qklbishe.com区块链毕设代做网专注|以太坊fabric-计算机|java|毕业设计|代做平台 » huansky资料

提供最优质的资源集合

立即查看 了解详情