Android GUI系统-ViewTree遍历过程（五）

淡淡的烟草味﹌ 2022-06-02 01:16 105阅读 0赞

ViewTree的遍历过程performTraversals。

遍历过程主要对应三个函数performMeasure（计算大小），perforLayout（计算位置），performDraw（绘制内容）。具体看下这三个步骤执行的条件，及怎么执行的？

1）performMeasure

private void performTraversals() @ViewRootImpl.java{
    //mView是ViewTree的根。
    	final View host = mView;
    
    // mWinFrame是WMS计算后的结果，通过mWindowSession.relayout(...mWinFrame...)传递回来的。
    	Rect frame = mWinFrame;
    //mFirst是不是第一次执行performTraversal。
    	if (mFirst) {
    		mFullRedrawNeeded = true;
    		mLayoutRequested = true;
    	}else{
    		desiredWindowWidth = frame.width();
    		desiredWindowHeight = frame.height();
    //当前的宽高跟期望值不一致。
    		if (desiredWindowWidth != mWidth || desiredWindowHeight != mHeight) {
                  	mFullRedrawNeeded = true;
                  	mLayoutRequested = true;
                  	windowSizeMayChange = true;
    		}
    	}
    // measureHierarchy是第一次可能会调用performMeasure的地方。mStopped表示窗口的拥有者Activity处于stopped状态，所以这个窗口就不再是active的。
    	boolean layoutRequested = mLayoutRequested && (!mStopped || mReportNextDraw);
    	if (layoutRequested) {
    		windowSizeMayChange |= measureHierarchy(host, lp, res,
    			desiredWindowWidth, desiredWindowHeight);
    	}
    }

//是否执行performMeasure，前面的layoutRequested是其中一部分条件，measureHierarchy方法中还有一些判断。

private boolean measureHierarchy(final View host, final WindowManager.LayoutParams lp,final 	Resources res, final int desiredWindowWidth, final int desiredWindowHeight) {
    	boolean goodMeasure = false;
    //View请求的宽是 WRAP_CONTENT。
    	if (lp.width == ViewGroup.LayoutParams.WRAP_CONTENT) {
    // mTmpValue是期望的对话框的最大宽度，
    		res.getValue(com.android.internal.R.dimen.config_prefDialogWidth, mTmpValue, true);
    		if (baseSize != 0 && desiredWindowWidth > baseSize) {
    			performMeasure(childWidthMeasureSpec, childHeightMeasureSpec);
    		}
    	}
    
    //如果View请求的宽度不是 WRAP_CONTENT， goodMeasure为false，会执行 performMeasure。
    	if (!goodMeasure) {
    		childWidthMeasureSpec = getRootMeasureSpec(desiredWindowWidth, lp.width);
    		childHeightMeasureSpec = getRootMeasureSpec(desiredWindowHeight, lp.height);
    		performMeasure(childWidthMeasureSpec, childHeightMeasureSpec);
    	}
    }

如果上面的条件没能满足performMeasure的执行条件，performTraversals往下走，还有判断是不是执行performMeasure。

private void performTraversals() @ViewRootImpl.java{
    // mStopped当前activity不处于stoped状态； mReportNextDraw通常在点亮屏幕扥带第一次绘制时，用于加快systemUI跟窗口管理之间的交互时，设置为true。
    	if (!mStopped || mReportNextDraw) {
    //触摸模式是否引起焦点变化。
    		boolean focusChangedDueToTouchMode = ensureTouchModeLocally(
    		(relayoutResult&WindowManagerGlobal.RELAYOUT_RES_IN_TOUCH_MODE) != 0);
    //WMS计算后得到的宽高跟View经过onMeasure计算的值不一致。
    		if (focusChangedDueToTouchMode || mWidth != host.getMeasuredWidth()
    			|| mHeight != host.getMeasuredHeight() || contentInsetsChanged ||
    			updatedConfiguration) {
    			performMeasure(childWidthMeasureSpec, childHeightMeasureSpec);
    		}
    	}
    }

以上条件满足，开始执行performMeasure。

private void performMeasure(int childWidthMeasureSpec, int childHeightMeasureSpec) {
    //直接调用ViewTree的根元素mView的 measure，View中measure和onMeasure子类都可以重载，通常建议重载onMeasure，测量工作也是onMeasure中进行的。
    	mView.measure(childWidthMeasureSpec, childHeightMeasureSpec);
    }

measure方法会调用onMeasure执行实际的测量工作。

protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) @View.java{
    	setMeasuredDimension(getDefaultSize(getSuggestedMinimumWidth(), widthMeasureSpec),
    		getDefaultSize(getSuggestedMinimumHeight(), heightMeasureSpec));
    }

其中的参数widthMeasureSpec，heightMeasureSpec是上一级父View要求的宽高，依次往下传递到viewTree的各个元素。在ViewRootImpl中，这两个值是通过getRootMeasureSpec计算得出的，然后传给ViewTree的根元素DecorView。

子类在重写onMeasure方法时，必须调用setMeasuredDimension来存储该view测量后的宽高。

插播下widthMeasureSpec，heightMeasureSpec这两个值的解释，这两个值是通过

childWidthMeasureSpec = MeasureSpec.makeMeasureSpec(width, MeasureSpec.EXACTLY);

计算出来的，MeasureSpec是View的子类，也即是说widthMeasureSpec这个int值中包含了两部分，一是size，一是mode（MeasureSpec.EXACTLY），详细看下它的格式：

View.java

public static class MeasureSpec {
    
            private static final int MODE_SHIFT = 30;
    
            private static final int MODE_MASK  = 0x3 << MODE_SHIFT;
    
            public static int makeMeasureSpec(@IntRange(from = 0, to = (1 << MeasureSpec.MODE_SHIFT) - 1) int size,
                                              @MeasureSpecMode int mode) {
                if (sUseBrokenMakeMeasureSpec) {
                    return size + mode;
                } else {
                    return (size & ~MODE_MASK) | (mode & MODE_MASK);
                }
            }
    
    }

IntRange 表表示size应该在一个范围内，重点看(size & ~MODE\_MASK) | (mode & MODE\_MASK);

MODE\_MASK　是0x3左移３０位，结果是0x11000等等后面都是０，所以size & ~MODE\_MASK即是把size的最高两位空出来了，而mode & MODE\_MASK　等于只取mode的最高两位，最终的结果：(size & ~MODE\_MASK) | (mode & MODE\_MASK)　的最高两位是mode，剩余的位数表示size。

看一个具体View的子类，如何重写onMeasure。

protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) @FrameLayout.java{
    	int count = getChildCount();
    //循环处理所有的子View。
    	for (int i = 0; i < count; i++) {
    		final View child = getChildAt(i);
    //测量每个子对象，条件是 mMeasureAllChildren为true，相关的属性是：android.R.styleable#FrameLayout_measureAllChildren；并且View是可见的。
    		if ( mMeasureAllChildren || child.getVisibility() != GONE) {
    //测量子对象，考虑padding，margins，如果子view是个ViewGroup，则会调用其child.measure函数继续递归，直到叶节点。
    			measureChildWithMargins(child, widthMeasureSpec, 0, heightMeasureSpec, 0);
    //得到view（Child）的计算结果，child.getMeasuredWidth()对应了View的MeasuredWidth变量，这个值通常是在onMeasure结束时通过setMeasuredDimension来设置的。
                    	maxWidth = Math.max(maxWidth,
                            child.getMeasuredWidth() + lp.leftMargin + lp.rightMargin);
                    	maxHeight = Math.max(maxHeight,
                            child.getMeasuredHeight() + lp.topMargin + lp.bottomMargin);
    		}
    	}
    
    //考虑其他因素，如padding，对于View类来说，它只有padding，padding指的是内容区域与外围边框的距离，有left、top、right、bottom四个值；对于ViewGroup来说，除了padding，还有margin，margin指的是内容中各个元素之间的距离。
            maxWidth += getPaddingLeftWithForeground() + getPaddingRightWithForeground();
            maxHeight += getPaddingTopWithForeground() + getPaddingBottomWithForeground();
    
    //对前面测量的宽高的最大值做调整，
            maxHeight = Math.max(maxHeight, getSuggestedMinimumHeight());
            maxWidth = Math.max(maxWidth, getSuggestedMinimumWidth());
    
    //保存测量的结果。
            setMeasuredDimension(resolveSizeAndState(maxWidth, widthMeasureSpec, childState),
                    resolveSizeAndState(maxHeight, heightMeasureSpec,
                            childState << MEASURED_HEIGHT_STATE_SHIFT));
    }

2）performLayout计算位置。

private void performTraversals() @ViewRootImpl.java{
    	final boolean didLayout = layoutRequested && (!mStopped || mReportNextDraw);
    //这个条件跟前面performMeasure类似， mWidth， mHeight是由WMS计算后的值，表示WMS期望的宽高。
    	if (didLayout) {
    		performLayout(lp, mWidth, mHeight);
    	}
    }

private void performLayout(WindowManager.LayoutParams lp, int desiredWindowWidth,int desiredWindowHeight) @ViewRootImpl.java{
    	final View host = mView;
    //调用的ViewTree根元素的方法 layout，传入的参数也是DecorView的测量后的宽高。
    	host.layout(0, 0, host.getMeasuredWidth(), host.getMeasuredHeight());
    }

子类不应该重载layout方法，而是应该重载onLayout方法，然后在onLayout方法中，调用每个子view的layout方法。四个参数表示的是这个view相对于它的父view四个方向的位置。

public void layout(int l, int t, int r, int b) {
    //通过setFrame将这4个边距记录到成员变量中mLeft;mTop;mBottom;mRight;
    	boolean changed = isLayoutModeOptical(mParent) ?
    		setOpticalFrame(l, t, r, b) : setFrame(l, t, r, b);
    
    //view.java中的onLayout是null的，调用具体子类的onLayout。
    	if (changed || (mPrivateFlags & PFLAG_LAYOUT_REQUIRED) == 			
    		PFLAG_LAYOUT_REQUIRED) {
    		onLayout(changed, l, t, r, b);
    	}
    //将flag恢复。
    	mPrivateFlags &= ~PFLAG_FORCE_LAYOUT;
    }

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

void layoutChildren(int left, int top, int right, int bottom, boolean forceLeftGravity) 
    	@FrameLayout.java{
    	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) {
    //子view设置的layout属性。
    			final LayoutParams lp = (LayoutParams) child.getLayoutParams();
    //在onMeasure中计算的宽高，这里在计算出left，top就可以确定一个子view在父View中具体位置。
    			final int width = child.getMeasuredWidth();
    			final int height = child.getMeasuredHeight();
    			int childLeft;
    			int childTop;
    // gravity属性，是在不改变子View大小的情况下，控制其在父View中的位置，比如放在父对象的顶部、左部、垂直居中、水平居中等。
    			int gravity = lp.gravity;
    			final int layoutDirection = getLayoutDirection();
    			final int absoluteGravity = Gravity.getAbsoluteGravity(gravity, layoutDirection);
    			final int verticalGravity = gravity & Gravity.VERTICAL_GRAVITY_MASK;
    //根据具体的布局属性，计算left。
    			switch (absoluteGravity & Gravity.HORIZONTAL_GRAVITY_MASK) {
                        	case Gravity.CENTER_HORIZONTAL:
                            childLeft = parentLeft + (parentRight - parentLeft - width) / 2 +
                            lp.leftMargin - lp.rightMargin;
                            break;
    			}
    //根据具体的布局属性，计算top。
    			 switch (verticalGravity) {
                        		case Gravity.CENTER_VERTICAL:
                           	 childTop = parentTop + (parentBottom - parentTop - height) / 2 +
                            	 lp.topMargin - lp.bottomMargin;
                          	  break;
    			}
    //调用子View的layout方法，依次递归下去。
    			child.layout(childLeft, childTop, childLeft + width, childTop + height);
    		}
    	}
    }

3）performDraw。遍历流程的最后一步，

private void performTraversals() @ViewRootImpl.java{
    	boolean cancelDraw = mAttachInfo.mTreeObserver.dispatchOnPreDraw() || !isViewVisible;
    // cancelDraw表示当前draw被取消，需要重新遍历； 在前面relayoutWindow过程中，如果WMS没有成功申请到surface，newSurface会置为true，这是也需要重新遍历。
    	if (!cancelDraw && !newSurface) {
    // performDraw重点调用了draw方法。
    		performDraw();
    	}
    }

图形绘制的方式分软件和硬件两种，什么时候会使用硬件方式绘制呢？

当执行Activity的onCreate方法时，调用了PhoneWindow.java的setContentView，接着调用了PhoneWindow.java的installDecor，

private void installDecor() @PhoneWindow.java{
    // mDecor为null时，调用 generateDecor传入的featureId是-1，这个id将会影响后期的绘制方式。
    	if (mDecor == null) {
    		mDecor = generateDecor(-1);
    	}else{…...}
    }

生成DecorView对象时，把这个featureId保存在DecorView的变量mFeatureId中。除了生成应用程序的DecorView时featureId是\-1，其他类型窗口的featureId都是大于0的值，如：

public abstract class Window @Window.java{
        /** Flag for the "options panel" feature.  This is enabled by default. */
        public static final int FEATURE_OPTIONS_PANEL = 0;
        /** Flag for the context menu.  This is enabled by default. */
        public static final int FEATURE_CONTEXT_MENU = 6;
        /**
         * Flag for enabling the Action Bar.
         * This is enabled by default for some devices. The Action Bar
         * replaces the title bar and provides an alternate location
         * for an on-screen menu button on some devices.
         */
        public static final int FEATURE_ACTION_BAR = 8;
    …...	
    }

只有featureid小于0时，willYouTakeTheSurface方法的返回值才可能不为null。

public android.view.SurfaceHolder.Callback2 willYouTakeTheSurface() @DecorView.java{
    	return mFeatureId < 0 ? mWindow.mTakeSurfaceCallback : null;
    }

在ViewRootImpl.java中，willYouTakeTheSurface方法的返回值，会影响到会不会生成对象mAttachInfo.mHardwareRenderer（mAttachInfo.mHardwareRenderer= ThreadedRenderer.create(mContext, translucent);）而这个对象判断绘制方式时会用到。

在回头看下performDraw调用的draw方法。

private void draw(boolean fullRedrawNeeded) @ViewRootImpl.java{
    //surface是画板，如果没有合法的surface，UI数据就无法正常存储和显示。
    	Surface surface = mSurface;
    	if (!dirty.isEmpty() || mIsAnimating || accessibilityFocusDirty) {
    //这个条件下，调用硬件绘制的方式。
    		if (mAttachInfo.mHardwareRenderer != null && 			
    			mAttachInfo.mHardwareRenderer.isEnabled()) {
    			mAttachInfo.mHardwareRenderer.draw(mView, mAttachInfo, this);
    		}else{
    //否则，调用软件绘制的方式。
    			if (!drawSoftware(surface, mAttachInfo, 
    				xOffset, yOffset, scalingRequired, dirty)) {
    				return;
    			}
    		}
    	}
    }

看下软件渲染是怎么绘制的。

private boolean drawSoftware(Surface surface, AttachInfo attachInfo, int xoff, int yoff,
                boolean scalingRequired, Rect dirty) @ViewRootImpl.java{
    //canvas是作画的工具集。
    	final Canvas canvas;
    //锁定一个canvas对象，将使用这个canvas把数据画到surface中。
    	canvas = mSurface.lockCanvas(dirty);
    
    	mView.mPrivateFlags |= View.PFLAG_DRAWN;
    //做必要的坐标变换。
    	canvas.translate(-xoff, -yoff);
    	mTranslator.translateCanvas(canvas);
    
    //从Viewtree的根开始绘制。
    	mView.draw(canvas);
    //绘制结束，解锁canvas，提交结果，canvas的绘制结果通过surface提交给surfacefligner，最后合成到framebuffer中，才能显示到屏幕上。
    	surface.unlockCanvasAndPost(canvas);
    }