View的绘制原理&渲染机制

深入理解Android之View的绘制流程
Android View的绘制流程知识点总结
Android View的渲染过程
关于 Android 渲染你应该了解的知识点
Android屏幕刷新机制原理分析

1.绘制流程从哪里开始

v2-45fd36622d21e7acd47f9abfaec297cf_r.jpg image.png

• Activity.setContentView() 其中getWindow()返回的是Activity所关联的PhoneWindow

public void setContentView(@LayoutRes int layoutResID) {    
  getWindow().setContentView(layoutResID);    
  . . .
}

• PhoneWindow.setContentView() ,递归性的解析xml，构建ViewTree，生成DecorView。

@Override
public void setContentView(int layoutResID) {
  if (mContentParent == null) {
    // mContentParent即为上面提到的ContentView的父容器，若为空则调用installDecor()生成
    installDecor();
  } else if (!hasFeature(FEATURE_CONTENT_TRANSITIONS)) {
    // 具有FEATURE_CONTENT_TRANSITIONS特性表示开启了Transition
    // mContentParent不为null，则移除decorView的所有子View
    mContentParent.removeAllViews();
  }
  if (hasFeature(FEATURE_CONTENT_TRANSITIONS)) {
    // 开启了Transition，做相应的处理，我们不讨论这种情况
    // 感兴趣的同学可以参考源码
    . . .
  } else {
    // 一般情况会来到这里，调用mLayoutInflater.inflate()方法来填充布局
    // 填充布局也就是把我们设置的ContentView加入到mContentParent中
    mLayoutInflater.inflate(layoutResID, mContentParent);
  }
  . . .
  // cb即为该Window所关联的Activity
  final Callback cb = getCallback();
  if (cb != null && !isDestroyed()) {
    // 调用onContentChanged()回调方法通知Activity窗口内容发生了改变
    cb.onContentChanged();
  }

  . . .
}

• ActivityThread

public final class ActivityThread {
   //ApplicationThread中会调用sendMessage(ActivtyThread.H.LAUNCH_ACTIVITY)
       private class H extends Handler {
            public static final int LAUNCH_ACTIVITY         = 100;
             public static final int RESUME_ACTIVITY         = 107;
             public static final int STOP_ACTIVITY_SHOW      = 103;
              public static final int PAUSE_ACTIVITY          = 101;
            public static final int DESTROY_ACTIVITY        = 109;
            public void handleMessage(Message msg) {
                   switch(msg.what){
                      case  LAUNCH_ACTIVITY :
                                 handleLaunchActivity();
                            break；
                       case  RESUME_ACTIVITY :
                                 handleResumeActivity();
                            break；
                       case  STOP_ACTIVITY_SHOW :
                                 handleStopActivity();
                            break；
                      case  PAUSE_ACTIVITY :
                                 handlePauseActivity();
                            break；
                        case  DESTROY_ACTIVITY:
                                 handleDestroyActivity();
                            break；
                   }
             } 
       }
         public Activity handleLaunchActivity() {
           final Activity a = performLaunchActivity(r, customIntent);
           return a;
        }
        public  Activity performLaunchActivity() {
               //attach方法中创建PhoneWindow，设置WindowManager
               activity.attach(appContext, this, getInstrumentation(), r.token,
                        r.ident, app, r.intent, r.activityInfo, title, r.parent,
                        r.embeddedID, r.lastNonConfigurationInstances, config,
                        r.referrer, r.voiceInteractor, window, r.activityConfigCallback,
                        r.assistToken, r.shareableActivityToken);
         /* onCreate方法setContentView，通过LayoutInflater把布局文件转换成一个java内存中ViewTree
             对象，主要的逻辑就是解析递归性的解析xml文件，把每个TAG，用反射的方式来生成一个View对 
             象，当Xml解析完成后，一颗View Tree就生成完了，但是需要注意的是，inflate之后,ViewTree 
            是创建好了，但是这仅仅是以单纯对象数据的形式存在，这时去获取View的GUI的相关属性，比如 
            大小，位置，渲染状态，是不存在的*/
             
                if (r.isPersistable()) {
                //>>>activity.performCreate()>>>Activity.onCreate() 
                    mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);
                } else {
                    mInstrumentation.callActivityOnCreate(activity, r.state);
                }
       }

         public void handleResumeActivity(ActivityClientRecord r) {
                   if (!performResumeActivity(r, finalStateRequest, reason)) {
                        return;
                  }
                 r.window = r.activity.getWindow();
                 View decor = r.window.getDecorView(); //通过后PhoneWindow获取DecorView
                 ViewManager wm = a.getWindowManager(); //获取WindowManagerImpl
                 wm.addView(decor, l);
       }
       public boolean performResumeActivity(){
           //>>>mInstrumentation.callActivityOnResume(this)>>>Activity.onResume()
             r.activity.performResume(r.startsNotResumed, reason);
       }
      public void handlePauseActivity(){
                   performPauseActivity();
      }
  
      private Bundle performPauseActivity(){
           //>>>activity.performPause()>>>onPause()
           mInstrumentation.callActivityOnPause(r.activity);
      }
      public void handleStopActivity(){
         performStopActivityInner();
     }
     private void  performStopActivityInner(){
         // >>>activity.onStop();
          mInstrumentation.callActivityOnStop(this);
    }
    public void handleDestroyActivity(){
         performDestroyActivity();
   }
   void performDestroyActivity(){
       //>>>activity.performDestroy()>>>onDestroy()
       mInstrumentation.callActivityOnDestroy(r.activity);
   }
}

• WindowManagerImpl

public final class WindowManagerImpl implements WindowManager {
   public void addView(@NonNull View view, @NonNull ViewGroup.LayoutParams params) {
        mGlobal.addView(view, params, mContext.getDisplayNoVerify(), mParentWindow,  
                mContext.getUserId());
    }
} 

• WindowManagerGlobal

public final class WindowManagerGlobal {
     public void addView(View view, ViewGroup.LayoutParams params) {
          ViewRootImpl root;
           if (windowlessSession == null) {
                root = new ViewRootImpl(view.getContext(), display);
            } else {
                root = new ViewRootImpl(view.getContext(), display,
                        windowlessSession);
            }
            root.setView(view, wparams, panelParentView, userId); 
    }

}

• ViewRootImpl (ViewGroup继承View)

(1).ViewRootImpl.performMeasure>>View.measure>>ViewGroup.onMeasure>>ViewGroup.measureChildWithMargins>>View.measure,如果当前view非ViewGroup，View.onMeasure>>View.setMeasuredDimension()测量View自身， 如果view是ViewGroup，ViewGroup会重写父类View.onMeasure()非空方法，会遍历子View,递归性的调用 View.measure()测量子View.

(2).ViewRootImpl.performLayout>>View.layout>>ViewGroup.onLayout>>ViewGroup.layoutChildren>>View.layout,如果当前view非ViewGroup，view.layout方法中会调用View.setFrame(l,t,r,b)定位自身， 如果view是ViewGroup，在ViewGroup会重写父类View.onLayout空方法，遍历子View，递归性的调用View.layout定位每个子View的大小.

(3).ViewRootImpl.pefromDraw>>ViewRootImpl.drawSoftware>>>>View.draw>>View.onDraw,ViewGroup.dispatchDraw>>ViewGroup.drawChild>>View.draw,如果当前view非ViewGroup，View.draw方法中会调用onDraw绘制自身（子View自己实现onDraw）），如果view是ViewGroup，在ViewGroup中会重写父类View中的diapatchDraw空方法，会遍历子View,,递归调用View.draw测量每个子View的大小.

public final class ViewRootImpl {
      public void requestLayout() {
        if (!mHandlingLayoutInLayoutRequest) {
            checkThread();
            mLayoutRequested = true;
            scheduleTraversals();
        }
    }

    void scheduleTraversals() {
        if (!mTraversalScheduled) {
            mTraversalScheduled = true;
            mTraversalBarrier = mHandler.getLooper().getQueue().postSyncBarrier();
          //执行mTraversalRunnable接口，调用 doTraversal()
            mChoreographer.postCallback(
                    Choreographer.CALLBACK_TRAVERSAL, mTraversalRunnable, null); 
            notifyRendererOfFramePending();
            pokeDrawLockIfNeeded();
        }
    }
     final TraversalRunnable mTraversalRunnable = new TraversalRunnable();
     final class TraversalRunnable implements Runnable {
        @Override
        public void run() {
            doTraversal();
        }
     }
    void doTraversal() {
         if (mTraversalScheduled) {
            mTraversalScheduled = false;
            mHandler.getLooper().getQueue().removeSyncBarrier(mTraversalBarrier);

             if (mProfile) {
                Debug.startMethodTracing("ViewAncestor");
             }

            performTraversals();

             if (mProfile) {
                Debug.stopMethodTracing();
                mProfile = false;
             }
           }
      }
    private void performTraversals() {
        measureHierarchy();

        performLayout(lp, mWidth, mHeight); //执行layout

        performDraw();//执行draw
    }
   private void measureHierarchy(){
       
         performMeasure(childWidthMeasureSpec, childHeightMeasureSpec); //執行測量
   }

   //传入performMeasure()方法的MeasureSpec的SpecMode为EXACTLY，SpecSize为窗口尺寸。
    private void performMeasure(int childWidthMeasureSpec, int childHeightMeasureSpec) {
         try { 
          childWidthMeasureSpec = getRootMeasureSpec(desiredWindowWidth, lp.width);
          childHeightMeasureSpec = getRootMeasureSpec(desiredWindowHeight, lp.height);
            mView.measure(childWidthMeasureSpec, childHeightMeasureSpec);
          } finally {
           . . .
         }
      }
}

其中getRootMeasureSpec()方法来获取MeasureSpec,这个根MeasureSpec代表了对DecorView的宽度的约束信息，现在我们来简单介绍一下MeasureSpec的概念。
MeasureSpec是一个32位整数，由SpecMode和SpecSize二部分组成，其中高2位为SpecMode，低30位
为SpecSize,SpecMode为测量模式，SpecSize为相应测量模式下的测量尺寸。View(包括普通View和ViewGroup)的SpecMode由View的LayoutParams结合父View的MeasureSpec生成。
SpecMode的取值可以分为以下三种：

• EXACTLY :父View期望子View的大小是(SpecSize).
• AT_MOST:父View期望子View的大小不得超过SpecSize.
• UNSPECIFIED:父View对子View的大小不作限制，通常用于系统内部.

2.View的整个绘制流程可以分为以下三个阶段：

• measure:判断是否需要重新计算View的大小，如果需要的话就重新计算。
• layout:判断是否需要重新计算View的位置，如果需要的话就重新计算。

• draw:判断是否需要重新绘制View，如果需要的话就重新绘制

  
  image.png

2.1.measure阶段

如果是普通View(非ViewGroup)来说，只需完成自身的测量工作即可，setMeasureDimension(),具体来说是以getDefaultSize()方法的返回值来作为测量结果。

public class View{
        public final void measure(int widthMeasureSpec, int heightMeasureSpec) {
               onMeasure(widthMeasureSpec, heightMeasureSpec);
        }
        public final void layout(int widthMeasureSpec, int heightMeasureSpec) {
               onMeasure(widthMeasureSpec, heightMeasureSpec);
        }
        public final void draw(int widthMeasureSpec, int heightMeasureSpec) {
                 if (!verticalEdges && !horizontalEdges) {
                        drawBackground(canvas);//绘制背景
                       onDraw(canvas);//绘制自己
                      dispatchDraw(canvas);//绘制子View
                 }           
       }
     protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
             setMeasuredDimension(getDefaultSize(getSuggestedMinimumWidth(), widthMeasureSpec),
             getDefaultSize(getSuggestedMinimumHeight(), heightMeasureSpec));
     } 
     // 在View中个空方法，在ViewGroup中是含有abstract关键字的空方法
       protected void onLayout(boolean changed, int left, int top, int right, int bottom) {

      }
     //在View中是个空方法
       protected void onDraw(Canvas canvas) {

       }
     //在View中是个空方法，在ViewGroup中具体实现
       protected void dispatchDraw(Canvas canvas) {

      }
 
        public static int getDefaultSize(int size, int measureSpec) {
            int result = size;
            int specMode = MeasureSpec.getMode(measureSpec);
            int specSize = MeasureSpec.getSize(measureSpec);
            switch (specMode) {
            case MeasureSpec.UNSPECIFIED:
                 result = size;
               break;
/*View的getDefaultSize()方法对于AT_MOST和EXACTLY这两种情况都返回了SpecSize作为result。
所以若我们的自定义View直接继承了View类，我们就要自己对wrap_content (对应了AT_MOST)
这种情况进行处理，否则对自定义View指定wrap_content就和match_parent效果一样了。
*/
            case MeasureSpec.AT_MOST:
            case MeasureSpec.EXACTLY:
                result = specSize;
                break;
          }
           return result;
      }
}

如果是ViewGroup，比如DecorView就是FrameLayout,遍历FrameLayout所有子View，逐一通过MeasureChildWithMargins()方法对子View进行测量，取所有子View中，宽度最大和高度最大的子View的宽度和高度作为maxWidth和maxHeight，而后将得到的maxWidth和maxHeight加上padding值，setMeasuredDimension(maxWidth，maxHeight)来确定FrameLayout的大小.

//重写的是View中的onMeasure方法
@Override
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
  int count = getChildCount();
  int maxHeight = 0;
  int maxWidth = 0;

  int childState = 0;
  for (int i = 0; i < count; i++) {
    final View child = getChildAt(i);
    if (mMeasureAllChildren || child.getVisibility() != GONE) {
      measureChildWithMargins(child, widthMeasureSpec, 0, heightMeasureSpec, 0);
      final LayoutParams lp = (LayoutParams) child.getLayoutParams();
      maxWidth = Math.max(maxWidth,
          child.getMeasuredWidth() + lp.leftMargin + lp.rightMargin);
      maxHeight = Math.max(maxHeight,
          child.getMeasuredHeight() + lp.topMargin + lp.bottomMargin);
      childState = combineMeasuredStates(childState, child.getMeasuredState());
    }
  }
  maxWidth += getPaddingLeftWithForeground() + getPaddingRightWithForeground();
  maxHeight += getPaddingTopWithForeground() + getPaddingBottomWithForeground();

  // Check against our minimum height and width
  maxHeight = Math.max(maxHeight, getSuggestedMinimumHeight());
  maxWidth = Math.max(maxWidth, getSuggestedMinimumWidth());

  // Check against our foreground's minimum height and width
  final Drawable drawable = getForeground();
  if (drawable != null) {
    maxHeight = Math.max(maxHeight, drawable.getMinimumHeight());
    maxWidth = Math.max(maxWidth, drawable.getMinimumWidth());
  }

  setMeasuredDimension(resolveSizeAndState(maxWidth, widthMeasureSpec, childState),
        resolveSizeAndState(maxHeight, heightMeasureSpec,
        childState << MEASURED_HEIGHT_STATE_SHIFT));
  . . . 
}

容器View通过measureChildWithMargins()方法对所有子View进行测量后，才能得到自身的测量结果。也就是说，对于ViewGroup及其子类来说，要先完成子View的测量，再进行自身的测量（考虑进padding等）

protected void measureChildWithMargins(View child,
  int parentWidthMeasureSpec, int widthUsed,
  int parentHeightMeasureSpec, int heightUsed) {
  final MarginLayoutParams lp = (MarginLayoutParams) child.getLayoutParams();

  final int childWidthMeasureSpec = getChildMeasureSpec(parentWidthMeasureSpec,
      mPaddingLeft + mPaddingRight + lp.leftMargin + lp.rightMargin + widthUsed, lp.width);
  final int childHeightMeasureSpec = getChildMeasureSpec(parentHeightMeasureSpec
      mPaddingTop + mPaddingBottom + lp.topMargin + lp.bottomMargin + heightUsed, lp.height);
   //调用子View的measure()方法进行测量
  child.measure(childWidthMeasureSpec, childHeightMeasureSpec);
}

getChildMeasureSpec()此方法展现了根据父View的MeasureSpec和子View的LayoutParams生成子View的MeasureSpec的过程。
当父View的SpecMode为EXACTLY时，表示父View对子View指定了确切的宽高限制。

• childDimension>=0:表示子View指定了具体大小，那么子View的SpceMode就是EXACTLY, SpceSize=childDemension。
• childDimension==match_parent :此时表示子View想和父View一样大，那么子View的SpecMode就是EXACTLY,SpecSize=size;
• childDimension==wrap_content:表示子View想自己决定自己的尺寸，那么子View的SpecMode就是AT_MOST,SpecSize=size;

当父View的SpecMode为AT_MOST时，表示父View对子View没有指定确切的宽高限制.

• childDimension>=0：表示子View指定了具体的大小，那么子View的SpecMode 就是EXACTLY，SpecSize=childDemension;
• childDimension==match_parent:表示子View的大小和父View一样大，但是父View还无法确定自身的大小，所以子View的SpceMode就是 AT_MOST,SpecSize=size;
• childDimension==wrap_content:表示子View想自己决定自己的大小，但是父View还无法确定自身的大小，所以子View的SpecMode就是AT_MOST,SpaceSize=size;

public static int getChildMeasureSpec(int spec, int padding, int childDimension) {
  // spec为父View的MeasureSpec
  // padding为父View在相应方向的已用尺寸加上父View的padding和子View的margin
  // childDimension为子View的LayoutParams的值
  int specMode = MeasureSpec.getMode(spec);
  int specSize = MeasureSpec.getSize(spec);

  // 现在size的值为父View相应方向上的可用大小
  int size = Math.max(0, specSize - padding);

  int resultSize = 0;
  int resultMode = 0;

  switch (specMode) {
    // Parent has imposed an exact size on us
    case MeasureSpec.EXACTLY:
      if (childDimension >= 0) {
        // 表示子View的LayoutParams指定了具体大小值（xx dp）
        resultSize = childDimension;
        resultMode = MeasureSpec.EXACTLY;
      } else if (childDimension == LayoutParams.MATCH_PARENT) {//MATCH_PARENT=-1
        // 子View想和父View一样大
        resultSize = size;
        resultMode = MeasureSpec.EXACTLY;
      } else if (childDimension == LayoutParams.WRAP_CONTENT) {//WRAP_CONTENT=-2
        // 子View想自己决定其尺寸，但不能比父View大 
        resultSize = size;
        resultMode = MeasureSpec.AT_MOST;
      }
      break;

    // Parent has imposed a maximum size on us
    case MeasureSpec.AT_MOST:
      if (childDimension >= 0) {
        // 子View指定了具体大小
        resultSize = childDimension;
        resultMode = MeasureSpec.EXACTLY;
      } else if (childDimension == LayoutParams.MATCH_PARENT) {
        // 子View想跟父View一样大，但是父View的大小未固定下来
        // 所以指定约束子View不能比父View大
        resultSize = size;
        resultMode = MeasureSpec.AT_MOST;
      } else if (childDimension == LayoutParams.WRAP_CONTENT) {
        // 子View想要自己决定尺寸，但不能比父View大
        resultSize = size;
        resultMode = MeasureSpec.AT_MOST;
      }
      break;
      . . .
  }

  //noinspection ResourceType
  return MeasureSpec.makeMeasureSpec(resultSize, resultMode);
}

2.2.Layout阶段(基本思想也是由根View开始，递归地完成整个控件树的布局（layout）工作)

• View.layout() 这个方法会调用setFrame()方法来设置View的mLeft、mTop、mRight和mBottom四个参数，这四个参数描述了View相对其父View的位置（分别赋值为l, t, r, b），在setFrame()方法中会判断View的位置是否发生了改变，若发生了改变，则需要对子View进行重新布局，对子View的局部是通过onLayout()方法实现了。由于普通View（ 非ViewGroup）不含子View，所以View类的onLayout()方法为空。因此接下来，我们看看ViewGroup类的onLayout()方法的实现。

public void layout(int l, int t, int r, int b) {
    // l为本View左边缘与父View左边缘的距离
    // t为本View上边缘与父View上边缘的距离
    // r为本View右边缘与父View左边缘的距离
    // b为本View下边缘与父View上边缘的距离
    . . .
    boolean changed = isLayoutModeOptical(mParent) ?
   setOpticalFrame(l, t, r, b) : setFrame(l, t, r, b);

    if (changed || (mPrivateFlags & PFLAG_LAYOUT_REQUIRED) == PFLAG_LAYOUT_REQUIRED) {

        onLayout(changed, l, t, r, b);//onLayout在View中是个空方法
        . . .
            
    }
    . . .
}

• ViewGroup.onLayout实际上该方法是abstract，这是因为不同的布局管理器有着不同的布局方式，这里我们还是以decorView，也就是FrameLayout的onLayout为例子，分析ViewGroup的布局过程:
  遍历ViewGroup中的所有子View,拿到每个View对应的左上右下的值，然后调用child.layout(l,t,r,b)进行定位设置，如果子View是容器View，则会递归的对其子View进行布局。

@Override
protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
  layoutChildren(left, top, right, bottom, false /* no force left gravity */);
}

void layoutChildren(int left, int top, int right, int bottom, boolean forceLeftGravity) {
  final int count = getChildCount();
  final int parentLeft = getPaddingLeftWithForeground();
  final int parentRight = right - left - getPaddingRightWithForeground();
  final int parentTop = getPaddingTopWithForeground();
  final int parentBottom = bottom - top - getPaddingBottomWithForeground();

  for (int i = 0; i < count; i++) {
    final View child = getChildAt(i);
    if (child.getVisibility() != GONE) {
      final LayoutParams lp = (LayoutParams) child.getLayoutParams();
      final int width = child.getMeasuredWidth();
      final int height = child.getMeasuredHeight();
      int childLeft;
      int childTop;
      int gravity = lp.gravity;

      if (gravity == -1) {
        gravity = DEFAULT_CHILD_GRAVITY;
      }

      final int layoutDirection = getLayoutDirection();
      final int absoluteGravity = Gravity.getAbsoluteGravity(gravity, layoutDirection);
      final int verticalGravity = gravity & Gravity.VERTICAL_GRAVITY_MASK;

      switch (absoluteGravity & Gravity.HORIZONTAL_GRAVITY_MASK) {
        case Gravity.CENTER_HORIZONTAL:
          childLeft = parentLeft + (parentRight - parentLeft - width) / 2 +
          lp.leftMargin - lp.rightMargin;
          break;
        case Gravity.RIGHT:
          if (!forceLeftGravity) {
            childLeft = parentRight - width - lp.rightMargin;
            break;
          }
        case Gravity.LEFT:
        default:
          childLeft = parentLeft + lp.leftMargin;
      }
      switch (verticalGravity) {
        case Gravity.TOP:
          childTop = parentTop + lp.topMargin;
          break;

        case Gravity.CENTER_VERTICAL:
          childTop = parentTop + (parentBottom - parentTop - height) / 2 +
           lp.topMargin - lp.bottomMargin;
          break;
        case Gravity.BOTTOM:
          childTop = parentBottom - height - lp.bottomMargin;
          break;
        default:
          childTop = parentTop + lp.topMargin;
      }
      child.layout(childLeft, childTop, childLeft + width, childTop + height);
    }
  }
}

2.3.draw阶段(perfromDraw>>draw>>drawSoftWare>>mView.draw())

• View.draw()实际上，View类的onDraw()方法为空，因为每个View绘制自身的方式都不尽相同，对于decorView来说，由于他是FrameLayout，他是容器View,所以他本身并没有什么需要绘制的。dispatchDraw()方法来绘制子View

  //canvas = mSurface.lockCanvas(dirty);//canvas是通过Surface获取的
public void draw(Canvas canvas) {
  // 绘制背景，只有dirtyOpaque为false时才进行绘制，下同
  int saveCount;
  if (!dirtyOpaque) {
    drawBackground(canvas);
  }
  // 绘制自身内容
  if (!dirtyOpaque) onDraw(canvas);

  // 绘制子View
  dispatchDraw(canvas);//在View中是个空方法，在ViewGroup中具体实现
  // 绘制滚动条等
  onDrawForeground(canvas);
}

• ViewGroup.dispatchDraw() 遍历ViewGroup中的所有子View，然后调用View.draw方法绘制自身

  @Override
    protected void dispatchDraw(Canvas canvas) {
         for (int i = 0; i < childrenCount; i++) {
            while (transientIndex >= 0 && mTransientIndices.get(transientIndex) == i) {
                final View transientChild = mTransientViews.get(transientIndex);
                if ((transientChild.mViewFlags & VISIBILITY_MASK) == VISIBLE ||
                        transientChild.getAnimation() != null) {
                    more |= drawChild(canvas, transientChild, drawingTime);  
                }
                transientIndex++;
                if (transientIndex >= transientCount) {
                    transientIndex = -1;
                }
            }

            final int childIndex = getAndVerifyPreorderedIndex(childrenCount, i, customOrder);
            final View child = getAndVerifyPreorderedView(preorderedList, children, childIndex);
            if ((child.mViewFlags & VISIBILITY_MASK) == VISIBLE || child.getAnimation() != null) {
                more |= drawChild(canvas, child, drawingTime);
            }
        }
    }

  protected boolean drawChild(Canvas canvas, View child, long drawingTime) {
        return child.draw(canvas, this, drawingTime); //调用View自身的draw()方法绘制自身.
    }

3.View的渲染机制

3.1. 基本概念

• CPU：执行应用层面的measure,layout,draw等绘制操作，绘制完成后交由OpenGL,Skia（底层图像渲染库）
• GPU：OpenGL,Skia库使用GPU处理数据，将数据发送到缓冲区
• 屏幕：由一个个像素组成，以固定频率（1000ms,60次 即16.66ms）从缓冲区里读取数据填充像素点。

image.png

3.2. Android渲染机制就是一个生产者和消费者的模型

image.png image.png

• 图像生成者 Choreographer ,每隔16.66ms收到SufaceFlinger的垂直同步信号，调用doFrame进行下一帧图形数据准备（Cpu对ViewTree进行pefromMeasure,perfomLayout,performDraw绘制，如果之前测量过，或者layout过，或者draw过，就不会再次递归性调用View.measure，View.layout,View.draw了），通过Surface获取canvas，canvas会把绘制指令传递到FrameWork层的RenderThread线程，RenderThread线程通过Surface.dequeue从BufferQueue中申请一块GraphicBuffer(图形缓冲区)，通过OpenGL或者Skia等底层图形渲染库调用GUP进行绘制填充，最后在把缓冲区交还给BufferQueue队列中.

• 消费者surfaceFlinger从队列中获取数据，对数据进行合成(DecorView和系统StatusBar)，合成了一帧完整的数据之后，就会和HAL通信，替换下一帧数据，等到收到Vsyn垂直同步信号的时候，下一帧数据就会替换当前帧数据，显示到屏幕上了.

• 注意SurfaceFlinger每隔16.66ms就会给HAL(Hardware Abstraction Layer)和应用层(Choreographer)发送一个Vsyn，Choreographer负责在主线程中完成绘制流程(如果主线程ViewTree发生变化，导致重绘，就会重新走View.measure,View.layout，View.draw 此时如果主线程被阻塞(STW，非主线程耗时操作)，可能会导致掉帧。

3.2. Choreograher绘制UI的流程
VIewRootImpl.requestLayout >>VIewRootImpl.scheduleTraversal>> Handler.Looper.MessageQueue.postSyncBarrier在队列中插入入一个同步屏障消息)>>ChoreoGrapher.postCallback(CALLBACK_TRAVERSAL)>>scheduleVsyncLocked(向Native层申请Vsyn)>>nativateScheduleVsync（向SurfaceFlinger注册了一个观察者）>> SurfaceFlinger每隔16.66ms之后，回回调观察者的onSync方法>>onSync>>Handler.sendMessageAtTime>>run>>doFrame>>doTraversal>>performMeasure>>performLayout>>performDraw.

3.3. 屏障消息的处理机制
(1).什么是屏障消息？
屏障消息就是没有Target的消息，不需要回调handleMessage,消息队列中的消息是按照时间顺序排列的，因此屏障消息会被插入到所有在其之前应该被处理的消息之后(队尾).
(2).为什么绘制消息的优先级最高，会被首先处理。

    // 向Handler发送一个消息，指定的时间执行，并且是异步消息
       Message msg = mHandler.obtainMessage(MSG_DO_SCHEDULE_CALLBACK, 
       action);
      msg.arg1 = callbackType;
      msg.setAsynchronous(true);
      mHandler.sendMessageAtTime(msg, dueTime);

原理：主线程的 Looper 会一直循环调用 MessageQueue 的 next() 来取出队头的 Message 执行，当 Message 执行完后再去取下一个。当 next() 方法在取 Message 时发现队头是一个同步屏障的消息时，就会去遍历整个队列，只寻找设置了异步标志（setAsynChronous(true)）的消息，如果有找到异步消息，那么就取出这个异步消息来执行，否则就让 next() 方法陷入阻塞状态。如果 next() 方法陷入阻塞状态，那么主线程此时就是处于空闲状态的，也就是没在干任何事。所以，如果队头是一个同步屏障的消息的话，那么在它后面的所有同步消息就都被拦截住了，直到这个同步屏障消息被移除，否则主线程就一直不会去处理同步屏障后面的同步消息.

image.png 1732099432146.png

4.View.invalidate分析

1732444078(1).png
1732445053(1).png

4.1.View.invalidate

public class View {

    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) {
          //fullInvalidate是true,  mPrivateFlags &= ~PFLAG_DRAWN 打上标记
           if (fullInvalidate) {
                mLastIsOpaque = isOpaque();
                mPrivateFlags &= ~PFLAG_DRAWN;
            }

            final AttachInfo ai = mAttachInfo;
            final ViewParent p = mParent;
            if (p != null && ai != null && l < r && t < b) {
                final Rect damage = ai.mTmpInvalRect; //把自身的位置传递给父View
                damage.set(l, t, r, b);
                p.invalidateChild(this, damage);
            }
   }
}

4.2.ViewGroup.invalidateChild

public class ViewGroup  implement ViewParent{
         public final void invalidateChild(View child, final Rect dirty) {
               ViewParent parent = this;
           //递归循环调用，最终Parent会变成ViewRootImpl,最终ViewRootImpl.invalidateChildParent
                do {
                      //location是父View的位置int[left,top]，dirty是子View的位置(Rect(l,t,r,b))
                      parent = parent.invalidateChildInParent(location, dirty);
                  } while (parent != null);
        }
       public ViewParent invalidateChildInParent(final int[] location, final Rect dirty) {
              //子View和父View的大小求交集
               if ((mGroupFlags & FLAG_CLIP_CHILDREN) == FLAG_CLIP_CHILDREN) {
                    dirty.set(0, 0, mRight - mLeft, mBottom - mTop);
                } else {
                    //子View和父View的大小求交集
                    dirty.union(0, 0, mRight - mLeft, mBottom - mTop);
                }
                location[CHILD_LEFT_INDEX] = mLeft; //当前View距离屏幕左边的距离
                location[CHILD_TOP_INDEX] = mTop;//当前View距离屏幕顶部的距离
                mPrivateFlags &= ~PFLAG_DRAWN; //打上绘制标记
               return parent；//返回父View
       }
}

4.3.ViewRootImpl.invalidateChildInParent

public class ViewRootImpl implement ViewParent{
     invalidateRectOnScreen(dirty);
}
 private void invalidateRectOnScreen(Rect dirty) {
       final Rect localDirty = mDirty;
       //父View和子View的大小求交集
       localDirty.union(dirty.left, dirty.top, dirty.right, dirty.bottom);
       if (!mWillDrawSoon && (intersected || mIsAnimating)) {
 //重新执行 doTraversal>>performMeasure>>performLayout>>performDraw
            scheduleTraversals(); 
        }
 }