Analysis mechanism principle in tween animation source code

[[438831]]

Preface

After the tween animation moves, why does the response to the click event remain in the original position?

So today we will analyze the principle from the source code

1. Tween animation

Tween animation can perform a series of simple transformations within a view container (specific transformation steps include: position, size, rotation, transparency);

We can perform specific operations through translation, rotation, scaling, transparency and other APIs;

The implementation of tween animation can be defined in two ways: XML or Android code;

1. XML implementation

File name: animator_translate.xml

 <?xml version= "1.0" encoding= "utf-8" ?>
 <translate
    xmlns:android= "http://schemas.android.com/apk/res/android"  
 android:fromXDelta= "0"  
 android:fromYDelta= "0"  
 android:toYDelta= "0"  
 android:toXDelta= "200"  
 android:duration= "500"  
    android:fillAfter= "true" >
 </translate>

Code to load XML file to get animation

 //Load animation
 Animation animation = AnimationUtils.loadAnimation(this, R.anim.animator_translate);
 //Execute animation
 testBtn.startAnimation(animation);

2. Code implementation

 TranslateAnimation translateAnimation = new TranslateAnimation(0,200,0,0);
 translateAnimation.setDuration(500); // animation execution time
 translateAnimation.setFillAfter( true ); //Keep the state after the animation is completed
 //Execute animation
 testBtn.startAnimation(translateAnimation);

2. Understanding the Principles of Tween Animation

1. startAnimation

startAnimation(rotateAnimation) method enters the source code;

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

First, the start time of the animation is set through setStartTime();

 // View .java
 public void setStartTime(long startTimeMillis) {
     mStartTime = startTimeMillis;
     mStarted = mEnded = false ;
 mCycleFlip = false ;
 mRepeated = 0;
 mMore = true ;
 }

Here we just assign values to some variables, let's take a look at the next method;

Set the animation setAnimation(animation):

 // View .java
 public void setAnimation(Animation animation) {
      mCurrentAnimation = animation;
      if (animation != null ) {
                if (mAttachInfo != null && mAttachInfo.mDisplayState == Display.STATE_OFF
                  && animation.getStartTime() == Animation.START_ON_FIRST_FRAME) {
              animation.setStartTime(AnimationUtils.currentAnimationTimeMillis());
 }
 animation.reset();
 }
 }

Here, the animation instance is also assigned to the current member variable;

Analyze invalidateParentCaches() in the startAnimation() method;

 // View .java
 protected void invalidateParentCaches()
     if (mParent instanceof View ) {
         (( View ) mParent).mPrivateFlags |= PFLAG_INVALIDATED;
 }
 }

You can see that this is just setting the animation flag, which is necessary when the view is constructed or the property changes;

Go back to the startAnimation() method and call invalidate(true);

2. invalidate

 // View .java
 public void invalidate(boolean invalidateCache) {
      invalidateInternal(0, 0, mRight - mLeft, mBottom - mTop, invalidateCache, true );
 }
  void invalidateInternal( int l, int t, int r, int b, boolean invalidateCache,
          boolean fullInvalidate) {
      if (mGhostView != null ) {
          mGhostView.invalidate( true );
 return ;
 }
 .................
          // Propagate the damage rectangle to the parent view .
          final AttachInfo ai = mAttachInfo;
          final ViewParent p = mParent;
          if (p != null && ai != null && l < r && t < b) {
              final Rect damage = ai.mTmpInvalRect;
              damage.set (l, t, r, b);
              p.invalidateChild(this, damage);
 }
 }
 }

Here we focus on p.invalidateChild(this, damage);

 //ViewGroup.java
 @Deprecated
 @Override
 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;
 .........
 do {
 View   view = null ;
              if (parent instanceof View ) {
 view = ( View ) parent;
 }
 .........
              parent = parent.invalidateChildInParent(location, dirty);
          } while (parent != null );
 }
 }

Because ViewParent p = mParent, this is ViewGroup, a subclass of View;
So p.invalidateChild(this, damage) actually calls ViewGroup's invalidateChild();
There is a do{}while() loop here. The first time, parent = this, that is, ViewGroup, and then call parent.invalidateChildInParent(location, dirty) method. When parent == null, the loop ends;
In the invalidateChildInParent method, mParent will be returned as long as the condition is met;

 //ViewGroup.java
 @Deprecated
 @Override
 public ViewParent invalidateChildInParent(final int [] location, final Rect dirty) {
      if ((mPrivateFlags & (PFLAG_DRAWN | PFLAG_DRAWING_CACHE_VALID)) != 0) {
 .......
 return mParent;
 }
 return   null ;
 }

((mPrivateFlags & (PFLAG_DRAWN | PFLAG_DRAWING_CACHE_VALID)) != 0) is still valid, so mParent will always be returned, which means that the mParent of View is ViewGroup;
The mParent of ViewGroup is also ViewGroup, and the do{}while() loop keeps looking for mParent, and the top mParent of a View is ViewRootImpl, so it finally goes to invalidateChildInParent() of ViewRootImpl;
In the onCreate() method, setContentView() is used to add the layout to a ViewGroup with DecorView as the root layout. After onResume() is executed, WindowManager will execute the addView() method, and then create a ViewRootImpl object and bind it to DecorView. The mParent of DecorView is set to ViewRootImpl, and ViewRootImpl implements the ViewParent interface. Therefore, ViewRootImpl does not inherit View or ViewGroup.
In the invalidateChildInParent() method of ViewRootImpl;

 //ViewRootImpl.java
 @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 ;
 }

Here all return values become null, and the previously executed do{}while() loop will also stop.

3. scheduleTraversals()

Then analyze the invalidateRectOnScreen(dirty) method;
Enter the scheduleTraversals() method;

 //ViewRootImpl.java
  private void invalidateRectOnScreen(Rect dirty) {
 ......
      if (!mWillDrawSoon && (intersected || mIsAnimating)) {
          scheduleTraversals();
 }
 }
 //ViewRootImpl.java
 void scheduleTraversals() {
      if (!mTraversalScheduled) {
          mTraversalScheduled = true ;
          mTraversalBarrier = mHandler.getLooper().getQueue().postSyncBarrier();
          mChoreographer.postCallback(
                  Choreographer.CALLBACK_TRAVERSAL, mTraversalRunnable, null );
          if (!mUnbufferedInputDispatch) {
              scheduleConsumeBatchedInput();
 }
          notifyRendererOfFramePending();
          pokeDrawLockIfNeeded();
 }
 }

Mainly looking at mTraversalRunnable, we find the mTraversalRunnable class;

 //ViewRootImpl.java
 final class TraversalRunnable implements Runnable {
 @Override
 public void run() {
 doTraversal();
 }
 }
  final TraversalRunnable mTraversalRunnable = new TraversalRunnable();

4. doTraversal()

doTraversal() method;

 //ViewRootImpl.java
 void doTraversal() {
 .......
          performTraversals();
 .......
 }
 }

scheduleTraversals() puts performTraversals() into a Runnable;
In Choreographer's execution queue, these pending Runables will be executed when the nearest 16.6ms screen refresh signal arrives;
And performTraversals() is the initiator of the three major operations of View: measurement, layout, and drawing;
In the Android screen refresh mechanism, any drawing request or layout request initiated by any View in the View tree will go to the scheduleTraversals() of ViewRootImpl, and then when the latest screen refresh signal comes, the performTraversals() of ViewRootImpl will traverse the View tree from the root layout DecorView to perform the three major operations of measurement, layout, and drawing.
Each refresh will go to ViewRootImpl, and then traverse layer by layer to the changed VIew to perform the corresponding layout and drawing operations;
Therefore, after calling View.startAnimation(rotateAnimation), the animation is not executed immediately. Instead, the variable initialization operation is performed to bind the View and Animation, call the redraw operation, search for mPartent internally, and finally initiate a request to traverse the View tree in ViewRootImpl's scheduleTraversals(). This request is executed when the most recent screen signal refresh arrives, and call performTraversals() to traverse the View tree from the root layout.

5. draw

Let's continue to analyze how the draw method draws the animation and how the animation is animated?
Invalidate will eventually call ViewRootImpl to register the Choreographer callback;
When the next VSYN signal arrives, ViewRootImpl performTraversals will be called, and eventually the View's draw method will be called.

 boolean draw(Canvas canvas, ViewGroup parent, long drawingTime) {
 ...
 // Clear the Transformation saved by the last animation
 if ((parentFlags & ViewGroup.FLAG_CLEAR_TRANSFORMATION) != 0) {
    parent.getChildTransformation().clear();
    parent.mGroupFlags &= ~ViewGroup.FLAG_CLEAR_TRANSFORMATION;
 }
 ......
 final Animation a = getAnimation();
 if (a != null ) {
 //Calculate the animation of the current frame based on the current time. More indicates whether more frames of animation need to be executed.
    more = applyLegacyAnimation(parent, drawingTime, a, scalingRequired);
    concatMatrix = a.willChangeTransformationMatrix();
 if (concatMatrix) {
        mPrivateFlags3 |= PFLAG3_VIEW_IS_ANIMATING_TRANSFORM;
 }
 //Get the transformation required for the current frame, this value will be set in applyLegacyAnimation
    transformToApply = parent.getChildTransformation();
 }
 ....
 if (transformToApply != null ) {
 if (concatMatrix) {
        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()); //Call the concat method of canvas here to achieve the final translation effect (matrix multiplication)
            canvas.translate(transX, transY);
 }
 //Mark that Tranformation needs to be cleared
        parent.mGroupFlags |= ViewGroup.FLAG_CLEAR_TRANSFORMATION;
 }
 float transformAlpha = transformToApply.getAlpha();
 if (transformAlpha < 1) {
        alpha *= transformAlpha;
        parent.mGroupFlags |= ViewGroup.FLAG_CLEAR_TRANSFORMATION;
 }
 }
 ...
 }

Call applyLegacyAnimation to calculate the animation of the current frame based on the current time and return a value indicating whether the animation has not yet been completed;
Get the transformation transformToApply required for the current frame;
Call canvas.concat method to achieve the final translation effect (matrix multiplication). In this way, we can draw the final translation onto canvas and solve the problem of how to complete the drawing.
Next, we will continue to analyze how applyLegacyAnimation calculates the animation of the current frame.

6. applyLegacyAnimation

 private boolean applyLegacyAnimation(ViewGroup parent, long drawingTime,
        Animation a, boolean scalingRequired) {
 ...
 //Get Transformation Each child View in ViewGroup uses a Transformation to create multiple Transformations frequently when multiple Views have animations
 //This is the same object as the transformToApply taken out in the draw method, which is the Transform that is finally applied to the Canvas
    final Transformation t = parent.getChildTransformation();
 //Call the getTransformation method of Animation to calculate the value of Transformation object according to the current time. The value of this object will eventually be assigned by the getTransformation method.
    boolean more = a.getTransformation(drawingTime, t, 1f);
    invalidationTransform = t;
 ...
 //If the animation has not finished playing, you need to loop the animation, which actually means continuing to call invalidate
 if (more) {
     if (parent.mInvalidateRegion == null ) {
                    parent.mInvalidateRegion = new RectF();
 }
                final RectF region = parent.mInvalidateRegion;
 //Call Animation's getInvalidateRegion to calculate parent's invalidateRegion based on invalidationTransform
                a.getInvalidateRegion(0, 0, mRight - mLeft, mBottom - mTop, region,
                        invalidationTransform);
                // The child needs to draw an animation, potentially offscreen, so
                // make sure we do not cancel invalidate requests
                parent.mPrivateFlags |= PFLAG_DRAW_ANIMATION;
 final int   left = mLeft + ( int ) region. left ;
 final int   top = mTop + ( int ) region. top ;
 //Call invalidate to execute the next drawing request, so that the animation will start moving
                parent.invalidate( left , top , left + ( int ) (region.width() + .5f),
 top + ( int ) (region.height() + .5f));
 }
 }

In the applyLegacyAnimation method, parent.invalidate will be called again to register a Choreographer callback, and the draw method will be called again after the next VSYN. This will create a loop;
Only when more is false, it means that the animation is finished and it will not be invalidated;
Continue to see how getTransformation calculates Transformation.

 //Animation.java
 //The return value indicates whether the animation has not been played to completion and needs to calculate outTransformation, that is, the changes that the animation needs to make
 public boolean getTransformation(long currentTime, Transformation outTransformation) {
 if (mStartTime == -1) {
 mStartTime = currentTime; //Record the time of the first frame
 }
 if (duration != 0) {
 normalizedTime = (( float ) (currentTime - (mStartTime + startOffset))) / //Calculate the progress of the operation (0-1) (current time - start time + offset) / total animation duration
            ( float ) duration;
 }
 final boolean expired = normalizedTime >= 1.0f || isCanceled(); //Judge whether the animation has been completed or canceled
 mMore = !expired;
 if (!mFillEnabled) normalizedTime = Math.max (Math.min ( normalizedTime, 1.0f), 0.0f); //Process the maximum value
 final float interpolatedTime = mInterpolator.getInterpolation(normalizedTime); //Current animation running progress calculated by the interpolator
 applyTransformation(interpolatedTime, outTransformation); //Calculate the final outTransformation based on the animation progress
 return mMore;
 }

Record the time of the first frame of animation;
Calculate the progress of the animation based on the duration from the current time to the first frame of the animation and the duration the animation should last;
Control the animation progress between 0-1. If it exceeds 1, it means the animation has ended and you can reassign it to 1.
Calculate the actual progress of the animation based on the interpolator;
Call applyTransformation() to apply the animation effect.

 //applyTransformationEach type of animation has its own implementationHere we take displacement animation as an example
 //TranslateAnimation.java
 @Override
    protected void applyTransformation( float interpolatedTime, Transformation t) {
 //Transformation can be understood as storing some transformation information of View , saving the change information to the member variable matrix
 float dx = mFromXDelta;
 float dy = mFromYDelta;
        if (mFromXDelta != mToXDelta) {
 dx = mFromXDelta + ((mToXDelta - mFromXDelta) * interpolatedTime); //Calculate the distance to move in the X direction
 }
        if (mFromYDelta != mToYDelta) {
 dy = mFromYDelta + ((mToYDelta - mFromYDelta) * interpolatedTime); //Calculate the distance to move in the Y direction
 }
 t.getMatrix().setTranslate(dx, dy); //Set the final result to Matrix
 }

At this point, the final change is calculated and applied to the Transformation's Matix. The Transformation is obtained in the draw method and applied to the Canvas, and canvas.concat is called to perform the translation animation.
If the animation has not been completed, the invalidate() method will be called again, and the ViewRootImpl will be notified layer by layer to initiate another traversal request when the next frame screen refresh signal comes;
When performingTraversals() is used to traverse the View tree and draw, the View's draw function is notified and called;
The applyLegacyAnimation() method will be called again to perform animation-related operations, including calling getTransformation() to calculate the animation progress and calling applyTransformation() to apply the animation.

7. Animation Summary

When View.startAnimation(Animation) is called, the animation is not executed immediately. Instead, a request to traverse the View tree is initiated through invalidate() layer by layer to ViewRootImpl. The drawing operation of traversing the View tree is initiated when the next (16ms) screen signal refresh is received. The traversal starts from DecorView. The draw() method is called when drawing. If the View has a bound animation, the applyLegacyAnimation() method is executed to process the related animation logic;
In applyLegacyAnimation(), first execute initialization initialize(), then notify the animation to start onAnimationStart(), and then calculate the animation progress through getTransformation(), and its return value and whether the animation is over determine whether to continue to notify ViewRootImpl to initiate a traversal request and view tree drawing. Repeat this step and call applyTransformation() to execute the animation logic until the animation ends.