Android窗口管理5　理解ViewRootImpl

最新推荐文章于 2024-05-04 19:12:46 发布
最新推荐文章于 2024-05-04 19:12:46 发布
阅读量2k 收藏 5
点赞数
分类专栏： Android framework
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liuwg1226/article/details/113100302
版权

一　概述

ViewRootImpl 是一个视图层次结构的顶部，可以理解为一个 Window 中所有 View 的根 View 的管理者（但 ViewRootImpl 不是 View，只是实现了 ViewParent 接口），实现了 View 和 WindowManager 之间的通信协议，实现的具体细节在 WindowManagerGlobal 这个类中。

在这里插入图片描述

简单来说 ViewRootImpl 是 View 与 WindowManager 之间联系的桥梁，作用总结如下：

１．将 DecorView 传递给 WindowManagerSerive
２．完成 View 的绘制过程，包括 measure、layout、draw 过程
３．向 DecorView 分发收到的用户发起的 event 事件，如按键，触屏等事件。

其中，ViewRootImpl 中包含了两个需要重点关注的内部类：

  • final class ViewRootHandler extends Handler 用于向 DecorView 分发事件
  • static class W extends IWindow.Stub

W 是 ViewRootImp l的一个嵌入类，也是一个 Binder 服务。通过 mWindowSession.addToDisplay 函数传入 WMS，用来在 WMS 中通过 Binder 回调。

二　将Window传递给WMS

public void setView(View view, WindowManager.LayoutParams attrs,
        View panelParentView) {
        synchronized (this) {
            if (mView == null) {
                mView = view;
               ......
                // Schedule the first layout -before- adding to the window
                // manager, to make sure we do the relayout before receiving
                // any other events from the system.
                requestLayout();//见下节介绍
                if ((mWindowAttributes.inputFeatures
                        & WindowManager.
                        LayoutParams.INPUT_FEATURE_NO_INPUT_CHANNEL) == 0) {
                    mInputChannel = new InputChannel();//生成InputChannel
                }
                ......
                try {
                    ......
                    //调用mWindowSession.addToDisplay通过binder调用到WMS
                    //实现对Window的真正的添加，这里的mWindow为 W 对象
                    res = mWindowSession.addToDisplay(mWindow, mSeq, ......);
                    setFrame(mTmpFrame);
                } catch (RemoteException e) {
                    ......
                } finally {
                    ......
                }
                ......               
                if (mInputChannel != null) {
                    if (mInputQueueCallback != null) {
                        mInputQueue = new InputQueue();
                        mInputQueueCallback.onInputQueueCreated(mInputQueue);
                    }
                    //用于输入事件的接收
                    mInputEventReceiver = 
                    new WindowInputEventReceiver(
                    mInputChannel, Looper.myLooper());
                }
               ......
            }
        }
    }

三　View的绘制

3.1 requestLayout

frameworks/base/core/java/android/view/View.java

public void requestLayout() {
    if (mMeasureCache != null) mMeasureCache.clear();
	// 步骤1
    if (mAttachInfo != null && mAttachInfo.mViewRequestingLayout == null) {
        ViewRootImpl viewRoot = getViewRootImpl();
        if (viewRoot != null && viewRoot.isInLayout()) {
            if (!viewRoot.requestLayoutDuringLayout(this)) {
                return;
            }
        }
        mAttachInfo.mViewRequestingLayout = this;
    }

	// 步骤2
    mPrivateFlags |= PFLAG_FORCE_LAYOUT;
    mPrivateFlags |= PFLAG_INVALIDATED;
    if (mParent != null && !mParent.isLayoutRequested()) {
        mParent.requestLayout();
    }
    if (mAttachInfo != null && mAttachInfo.mViewRequestingLayout == this) {
        mAttachInfo.mViewRequestingLayout = null;
    }
}

调用时机：
当某些变化导致原有 View 树的 layout 发生变化，可以调用 requestLayout 重新布局 View 树。

１．关于 requestLayout 的叠加

  • 尽量不要在 layout 过程中又调用 requestLayout
  • 如果非要叠加调用 requestLayout，则将当前作出该请求的 View 先放入 mLayoutRequesters 列表，等到调用 ViewRootImpl#performLayout 的时候再取出 mLayoutRequesters 列表依次调用各个 View#requestLayout。如果当前正在处理 mLayoutRequesters 列表，则不要再次触发 requestLayout

２．mParent.requestLayout()

  • 我们先搞清楚 mParent 是啥？
    mParent 的类型是 ViewParent，通过代码溯源 View#assignParent，可以得出如下结论：
    DecorView (即根 View) 对应的 mParent 是 ViewRootImpl，普通子 View (非根 View) 对应的 mParent 是子 View 的父 View (即 ViewGroup)

  • requestLayout 调用过程?
    该过程是一个从子 View -> 父 View -> DecorView -> ViewRootImpl 层层往上的递归调用过程

3.2 invalidate

frameworks/base/core/java/android/view/View.java

public void invalidate() {
    invalidate(true);
}

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 (skipInvalidate()) {
        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);
    }
    ......
}

frameworks/base/core/java/android/view/ViewGroup.java

@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;
    if (attachInfo != null) {
        final int[] location = attachInfo.mInvalidateChildLocation;
        location[CHILD_LEFT_INDEX] = child.mLeft;
        location[CHILD_TOP_INDEX] = child.mTop;
		......
        do {
            ......
            parent = parent.invalidateChildInParent(location, dirty);
            ......
        } while (parent != null);
    }
}

１．调用时机：
当前 View 树需要重绘时。如果当前 View 可见，则会调到 onDraw 方法。
该方法必须在 UI 线程调用。

２．View#invalidate 的调用逻辑：
从子 View -> 父 View -> DecorView -> ViewRootImpl 从子到父层层调用。

  • 硬件加速
    ViewGroup#onDescendantInvalidated -> …-> DecorView#onDescendantInvalidated -> ViewRootImpl#onDescendantInvalidated

  • 非硬件加速
    ViewGroup#invalidateChild -> ViewGroup#invalidateChildInParent -> … -> DecorView#invalidateChildInParent -> ViewRootImpl#invalidateChildInParent

３．skipInvalidate 逻辑

private boolean skipInvalidate() {
    return (mViewFlags & VISIBILITY_MASK) != VISIBLE && 
        mCurrentAnimation == null &&
            (!(mParent instanceof ViewGroup) ||
                    !((ViewGroup) mParent).isViewTransitioning(this));
}

如果当前 View 不可见并且当前没有动画时，则不会 invalidate 执行重绘．

3.3 postInvalidate

frameworks/base/core/java/android/view/View.java

public void postInvalidate() {
    postInvalidateDelayed(0);
}

public void postInvalidateDelayed(long delayMilliseconds) {
    final AttachInfo attachInfo = mAttachInfo;
    if (attachInfo != null) {
        attachInfo.mViewRootImpl.dispatchInvalidateDelayed(
        　　　　this, delayMilliseconds);
    }
}

frameworks/base/core/java/android/view/ViewRootImpl.java

public void dispatchInvalidateDelayed(View view, long delayMilliseconds) {
    Message msg = mHandler.obtainMessage(MSG_INVALIDATE, view);
    mHandler.sendMessageDelayed(msg, delayMilliseconds);
}

调用时机：
和 invalidate 类似。
不同的是，postInvalidate 通过发送一个消息到主线程的消息队列，在消息队列中执行 invalidate 方法。
因此 postInvalidate 可以在非 UI 线程调用。

3.4 requestLayout & invalidate & postInvalidate

相同点：

  • 都是从子 View -> 父 View -> DecorView -> ViewRootImpl 从子到父层层调用
  • 都会导致 View 树重绘，最终都会调用到 ViewRootImpl#scheduleTraversals

不同点：

  • requestLayout 在 UI 线程调用
  • invalidate 在 UI 线程调用。当 View 树可见时，会调用到 onDraw
  • postInvalidate 可以在非 UI 线程调用。逻辑和 invalidate 类似，不同点是 postInvalidate 通过发消息方式，使 invalidate 操作在消息队列里有序执行

四　ViewRootImpl的绘制

frameworks/base/core/java/android/view/ViewRootImpl.java

4.1 scheduleTraversals

void scheduleTraversals() {
    if (!mTraversalScheduled) {
        mTraversalScheduled = true;
        // 添加同步屏障
        mTraversalBarrier = 
            mHandler.getLooper().getQueue().postSyncBarrier();
        // 发送并执行遍历操作
        mChoreographer.postCallback(Choreographer.CALLBACK_TRAVERSAL,
            mTraversalRunnable, null);
        if (!mUnbufferedInputDispatch) {
            scheduleConsumeBatchedInput();
        }
        notifyRendererOfFramePending();
        pokeDrawLockIfNeeded();
    }
}

final class TraversalRunnable implements Runnable {
    @Override
    public void run() {
        doTraversal();
    }
}

void doTraversal() {
    if (mTraversalScheduled) {
        mTraversalScheduled = false;
        // 移除同步屏障
        mHandler.getLooper().getQueue().removeSyncBarrier(
            mTraversalBarrier); 
        performTraversals();
    }
}

同步屏障 SyncBarrier
当调用 postSyncBarrier 后，MessageQueue 中的同步消息将不能执行，直到 removeSyncBarrier 才会执行。这个不影响异步消息。

在设置了同步屏障后，发送一个 CALLBACK_TRAVERSAL 类型消息到 Choreographer 的消息队列。
在移除了同步屏障后，执行 performTraversals

4.2 performTraversals

private void performTraversals() {
    ......
    //如果当前View树中包含SurfaceView, 则执行surfaceCreated/surfaceChanged回调
    if (mSurfaceHolder != null) {
        if (mSurface.isValid()) {
            mSurfaceHolder.mSurface = mSurface;
        }
        mSurfaceHolder.setSurfaceFrameSize(mWidth, mHeight);
        if (mSurface.isValid()) {
            if (!hadSurface) {
                mSurfaceHolder.ungetCallbacks();
 
                mIsCreating = true;
                SurfaceHolder.Callback callbacks[] =
                    mSurfaceHolder.getCallbacks();
                if (callbacks != null) {
                    for (SurfaceHolder.Callback c : callbacks) {
                        c.surfaceCreated(mSurfaceHolder);
                    }
                }
                surfaceChanged = true;
            }
            if (surfaceChanged || surfaceGenerationId !=
                mSurface.getGenerationId()) {
                SurfaceHolder.Callback callbacks[] =
                    mSurfaceHolder.getCallbacks();
                if (callbacks != null) {
                    for (SurfaceHolder.Callback c : callbacks) {
                        c.surfaceChanged(mSurfaceHolder, lp.format,
                            mWidth, mHeight);
                    }
                }
            }
            mIsCreating = false;
        }
    } 
    ......
    // mWidth&mHeight为Frame宽高, lp为setView传进来的
    // WindowManager.LayoutParams参数
    int childWidthMeasureSpec = getRootMeasureSpec(mWidth, lp.width);
    int childHeightMeasureSpec = getRootMeasureSpec(mHeight, lp.height);
    performMeasure(childWidthMeasureSpec, childHeightMeasureSpec);
    ......
    performLayout(lp, mWidth, mHeight);
    ......
    // 调用OnGlobalLayoutListener#onGlobalLayout
    if (triggerGlobalLayoutListener) {
        mAttachInfo.mRecomputeGlobalAttributes = false;
        mAttachInfo.mTreeObserver.dispatchOnGlobalLayout();
    }
    ......
    performDraw();
    ......
}

主要做了一下工作：

  • 如果 View 树中当前 View 为 SurfaceView，则执行 surfaceCreated / surfaceChanged 相关回调
  • 依次执行 performMeasure -> performLayout -> performDraw
  • OnGlobalLayoutListener#onGlobalLayout 回调中可以获取到 View 的真实宽高。因为该方法在 performMeasure -> performLayout 后面执行

4.2.1 performMeasure

4.2.1.1 ViewRootImpl.performMeasure
private void performMeasure(int childWidthMeasureSpec,
    int childHeightMeasureSpec) {
    mView.measure(childWidthMeasureSpec, childHeightMeasureSpec);
}
4.2.1.2 View.measure
public final void measure(int widthMeasureSpec, int heightMeasureSpec) {
    boolean optical = isLayoutModeOptical(this);
    if (optical != isLayoutModeOptical(mParent)) {
        Insets insets = getOpticalInsets();
        int oWidth  = insets.left + insets.right;
        int oHeight = insets.top  + insets.bottom;
        widthMeasureSpec  = MeasureSpec.adjust(widthMeasureSpec,
            optical ? -oWidth  : oWidth);
        heightMeasureSpec = MeasureSpec.adjust(heightMeasureSpec,
            optical ? -oHeight : oHeight);
    }
 
    // Suppress sign extension for the low bytes
    long key = (long) widthMeasureSpec << 32 |
        (long) heightMeasureSpec & 0xffffffffL;
    if (mMeasureCache == null) mMeasureCache = new LongSparseLongArray(2);
 
    final boolean forceLayout =
        (mPrivateFlags & PFLAG_FORCE_LAYOUT) == PFLAG_FORCE_LAYOUT;
 
    // Optimize layout by avoiding an extra EXACTLY pass when the view is
    // already measured as the correct size. In API 23 and below, this
    // extra pass is required to make LinearLayout re-distribute weight.
    final boolean specChanged = widthMeasureSpec != mOldWidthMeasureSpec
            || heightMeasureSpec != mOldHeightMeasureSpec;
    final boolean isSpecExactly = 
    MeasureSpec.getMode(widthMeasureSpec) == MeasureSpec.EXACTLY
        && MeasureSpec.getMode(heightMeasureSpec) == MeasureSpec.EXACTLY;
    final boolean matchesSpecSize =
    getMeasuredWidth() == MeasureSpec.getSize(widthMeasureSpec)
        && getMeasuredHeight() == MeasureSpec.getSize(heightMeasureSpec);
    final boolean needsLayout = specChanged
        && (sAlwaysRemeasureExactly || !isSpecExactly || !matchesSpecSize);
 
    if (forceLayout || needsLayout) {
        // first clears the measured dimension flag
        mPrivateFlags &= ~PFLAG_MEASURED_DIMENSION_SET;
 
        resolveRtlPropertiesIfNeeded();
 
        int cacheIndex = forceLayout ? -1 : mMeasureCache.indexOfKey(key);
        if (cacheIndex < 0 || sIgnoreMeasureCache) {
            // measure ourselves, this should set 
            // the measured dimension flag back
            onMeasure(widthMeasureSpec, heightMeasureSpec);
            mPrivateFlags3 &= ~PFLAG3_MEASURE_NEEDED_BEFORE_LAYOUT;
        } else {
            long value = mMeasureCache.valueAt(cacheIndex);
        // Casting a long to int drops the high 32 bits, no mask needed
            setMeasuredDimensionRaw((int) (value >> 32), (int) value);
            mPrivateFlags3 |= PFLAG3_MEASURE_NEEDED_BEFORE_LAYOUT;
        }
 
        mPrivateFlags |= PFLAG_LAYOUT_REQUIRED;
    }
 
    mOldWidthMeasureSpec = widthMeasureSpec;
    mOldHeightMeasureSpec = heightMeasureSpec;
 
    mMeasureCache.put(key, ((long) mMeasuredWidth) << 32 |
        (long) mMeasuredHeight & 0xffffffffL); //suppress sign extension
}
4.2.1.3 View.onMeasure
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
    setMeasuredDimension(getDefaultSize(getSuggestedMinimumWidth(),
    widthMeasureSpec), getDefaultSize(getSuggestedMinimumHeight(),
    heightMeasureSpec));
}
4.2.1.4 View.setMeasuredDimension
protected final void setMeasuredDimension(int measuredWidth,
    int measuredHeight) {
    setMeasuredDimensionRaw(measuredWidth, measuredHeight);
}

private void setMeasuredDimensionRaw(int measuredWidth, int measuredHeight) {
    mMeasuredWidth = measuredWidth;
    mMeasuredHeight = measuredHeight; 
    mPrivateFlags |= PFLAG_MEASURED_DIMENSION_SET;
}

１．Measure 过程调用链路
ViewRootImpl#performMeasure -> View#measure -> View#onMeasure -> View#setMeasureDimension

２．缓存策略
为了避免每次重复测量，采用了缓存策略。测量缓存数据结构 LongSparseLongArray
其中 key 为 MeasureSpec，value 为 MeasuredWidth/MeasuredHeight。高 32 位代表宽度，低 32 位代表高度。

// key
(long) widthMeasureSpec << 32 | (long) heightMeasureSpec & 0xffffffffL  
// value
(long) mMeasuredWidth << 32 |  (long) mMeasuredHeight & 0xffffffffL

３．测量过程
如果缓存中没有，则需要测量方法 View#onMeasure。具体的测量宽高方式参考 getDefaultSize。
其中 size 为建议大小 getSuggestedMinimumWidth/Height，measureSpec 为测量规范。

protected int getSuggestedMinimumWidth() {
    return (mBackground == null) ? mMinWidth :
        max(mMinWidth, mBackground.getMinimumWidth());
}

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;
    case MeasureSpec.AT_MOST:
    case MeasureSpec.EXACTLY:
        result = specSize;
        break;
    }
    return result;
}

４．MeasureSpec
上面提到了 int measureSpec 为测量规范。怎么理解这个测量规范呢? 可以用类 MeasureSpec 来描述。
MeasureSpec 由 mode 和 size 组成，前 2 位为 mode，后 30 位为 size。之所以这么设计，是出于节省内存考虑。有三种 mode 类型：

  • UNSPECIFIED 父 View 没有对子 View 做限制
  • EXACTLY 父 View 指定了子 View 的精确大小
  • AT_MOST 父 View 指定了子 View 的最大值，子 View 最大到达这个最大值
public static class MeasureSpec {
    private static final int MODE_SHIFT = 30;
    private static final int MODE_MASK  = 0x3 << MODE_SHIFT;

    public static final int UNSPECIFIED = 0 << MODE_SHIFT;
    public static final int EXACTLY     = 1 << MODE_SHIFT;
    public static final int AT_MOST     = 2 << MODE_SHIFT;

    @IntDef({UNSPECIFIED, EXACTLY, AT_MOST})
    @Retention(RetentionPolicy.SOURCE)
    public @interface MeasureSpecMode {}

    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);
        }
    }

    @MeasureSpecMode
    public static int getMode(int measureSpec) {
        //noinspection ResourceType
        return (measureSpec & MODE_MASK);
    }

    public static int getSize(int measureSpec) {
        return (measureSpec & ~MODE_MASK);
    }
}

4.2.2 performLayout

4.2.2.1 ViewRootImpl.performLayout
private void performLayout(WindowManager.LayoutParams lp,
    int desiredWindowWidth, int desiredWindowHeight) {
    mView.layout(0, 0, mView.getMeasuredWidth(), mView.getMeasuredHeight());
}
4.2.2.2 View.layout
public void layout(int l, int t, int r, int b) {
    if ((mPrivateFlags3 & PFLAG3_MEASURE_NEEDED_BEFORE_LAYOUT) != 0) {
        onMeasure(mOldWidthMeasureSpec, mOldHeightMeasureSpec);
        mPrivateFlags3 &= ~PFLAG3_MEASURE_NEEDED_BEFORE_LAYOUT;
    }
 
    int oldL = mLeft;
    int oldT = mTop;
    int oldB = mBottom;
    int oldR = mRight;
 
    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);
 
        if (shouldDrawRoundScrollbar()) {
            if(mRoundScrollbarRenderer == null) {
                mRoundScrollbarRenderer = new RoundScrollbarRenderer(this);
            }
        } else {
            mRoundScrollbarRenderer = null;
        }
 
        mPrivateFlags &= ~PFLAG_LAYOUT_REQUIRED;
 
        ListenerInfo li = mListenerInfo;
        if (li != null && li.mOnLayoutChangeListeners != null) {
            ArrayList<OnLayoutChangeListener> listenersCopy =
                (ArrayList<OnLayoutChangeListener>)
                li.mOnLayoutChangeListeners.clone();
            int numListeners = listenersCopy.size();
            for (int i = 0; i < numListeners; ++i) {
                listenersCopy.get(i).onLayoutChange(
                this, l, t, r, b, oldL, oldT, oldR, oldB);
            }
        }
    }
 
    final boolean wasLayoutValid = isLayoutValid();
 
    mPrivateFlags &= ~PFLAG_FORCE_LAYOUT;
    mPrivateFlags3 |= PFLAG3_IS_LAID_OUT;
 
    if (!wasLayoutValid && isFocused()) {
        mPrivateFlags &= ~PFLAG_WANTS_FOCUS;
        if (canTakeFocus()) {
            // We have a robust focus, so parents 
            // should no longer be wanting focus.
            clearParentsWantFocus();
        } else if (getViewRootImpl() == null ||
            !getViewRootImpl().isInLayout()) {
            clearFocusInternal(null, /* propagate */ true,
            /* refocus */ false);
            clearParentsWantFocus();
        } else if (!hasParentWantsFocus()) {
            clearFocusInternal(null, /* propagate */ true,
            /* refocus */ false);
        }
    } else if ((mPrivateFlags & PFLAG_WANTS_FOCUS) != 0) {
        mPrivateFlags &= ~PFLAG_WANTS_FOCUS;
        View focused = findFocus();
        if (focused != null) {
            if (!restoreDefaultFocus() && !hasParentWantsFocus()) {
                focused.clearFocusInternal(null, /* propagate */ true,
                /* refocus */ false);
            }
        }
    }
 
    if ((mPrivateFlags3 & PFLAG3_NOTIFY_AUTOFILL_ENTER_ON_LAYOUT) != 0) {
        mPrivateFlags3 &= ~PFLAG3_NOTIFY_AUTOFILL_ENTER_ON_LAYOUT;
        notifyEnterOrExitForAutoFillIfNeeded(true);
    }
}

Layout过程调用链路：
ViewRootImpl#performLayout -> View#layout -> View#onLayout

4.2.3 performDraw

4.2.3.1 ViewRootImpl.performDraw
private void performDraw() {
    ......
    final Canvas canvas = mSurface.lockCanvas(dirty);
    canvas.setDensity(mDensity);
    canvas.translate(-xoff, -yoff);
    canvas.setScreenDensity(scalingRequired ? mNoncompatDensity : 0);
    ......
    mView.draw(canvas);
    surface.unlockCanvasAndPost(canvas);
}

performDraw 调用流程：
draw(fullRedrawNeeded) -> drawSoftware(surface, mAttachInfo, xOffset, yOffset, scalingRequired, dirty, surfaceInsets) -> mView.draw(canvas)

4.2.3.2 View.draw
public void draw(Canvas canvas) {
    final int privateFlags = mPrivateFlags;
    mPrivateFlags = (privateFlags & ~PFLAG_DIRTY_MASK) | PFLAG_DRAWN;
 
    // Step 1, draw the background, if needed
    int saveCount; 
    drawBackground(canvas);
 
    // skip step 2 & 5 if possible (common case)
    final int viewFlags = mViewFlags;
    boolean horizontalEdges = (viewFlags & FADING_EDGE_HORIZONTAL) != 0;
    boolean verticalEdges = (viewFlags & FADING_EDGE_VERTICAL) != 0;
    if (!verticalEdges && !horizontalEdges) {
        // Step 3, draw the content
        onDraw(canvas);
 
        // Step 4, draw the children
        dispatchDraw(canvas);
 
        drawAutofilledHighlight(canvas);
 
        // Overlay is part of the content and draws beneath Foreground
        if (mOverlay != null && !mOverlay.isEmpty()) {
            mOverlay.getOverlayView().dispatchDraw(canvas);
        }
 
        // Step 6, draw decorations (foreground, scrollbars)
        onDrawForeground(canvas);
 
        // Step 7, draw the default focus highlight
        drawDefaultFocusHighlight(canvas);
 
        if (debugDraw()) {
            debugDrawFocus(canvas);
        }
 
        // we're done...
        return;
    }
 
    boolean drawTop = false;
    boolean drawBottom = false;
    boolean drawLeft = false;
    boolean drawRight = false;
 
    float topFadeStrength = 0.0f;
    float bottomFadeStrength = 0.0f;
    float leftFadeStrength = 0.0f;
    float rightFadeStrength = 0.0f;
 
    // Step 2, save the canvas' layers
    int paddingLeft = mPaddingLeft;
 
    final boolean offsetRequired = isPaddingOffsetRequired();
    if (offsetRequired) {
        paddingLeft += getLeftPaddingOffset();
    }
 
    int left = mScrollX + paddingLeft;
    int right = left + mRight - mLeft - mPaddingRight - paddingLeft;
    int top = mScrollY + getFadeTop(offsetRequired);
    int bottom = top + getFadeHeight(offsetRequired);
 
    if (offsetRequired) {
        right += getRightPaddingOffset();
        bottom += getBottomPaddingOffset();
    }
 
    final ScrollabilityCache scrollabilityCache = mScrollCache;
    final float fadeHeight = scrollabilityCache.fadingEdgeLength;
    int length = (int) fadeHeight;
 
    // clip the fade length if top and bottom fades overlap
    // overlapping fades produce odd-looking artifacts
    if (verticalEdges && (top + length > bottom - length)) {
        length = (bottom - top) / 2;
    }
 
    // also clip horizontal fades if necessary
    if (horizontalEdges && (left + length > right - length)) {
        length = (right - left) / 2;
    }
 
    if (verticalEdges) {
        topFadeStrength = Math.max(0.0f, Math.min(1.0f,
            getTopFadingEdgeStrength()));
        drawTop = topFadeStrength * fadeHeight > 1.0f;
        bottomFadeStrength = Math.max(0.0f, Math.min(1.0f,
            getBottomFadingEdgeStrength()));
        drawBottom = bottomFadeStrength * fadeHeight > 1.0f;
    }
 
    if (horizontalEdges) {
        leftFadeStrength = Math.max(0.0f, Math.min(1.0f,
            getLeftFadingEdgeStrength()));
        drawLeft = leftFadeStrength * fadeHeight > 1.0f;
        rightFadeStrength = Math.max(0.0f, Math.min(1.0f,
            getRightFadingEdgeStrength()));
        drawRight = rightFadeStrength * fadeHeight > 1.0f;
    }
 
    saveCount = canvas.getSaveCount();
    int topSaveCount = -1;
    int bottomSaveCount = -1;
    int leftSaveCount = -1;
    int rightSaveCount = -1;
 
    int solidColor = getSolidColor();
    if (solidColor == 0) {
        if (drawTop) {
            topSaveCount = canvas.saveUnclippedLayer(
                left, top, right, top + length);
        }
 
        if (drawBottom) {
            bottomSaveCount = canvas.saveUnclippedLayer(
                left, bottom - length, right, bottom);
        }
 
        if (drawLeft) {
            leftSaveCount = canvas.saveUnclippedLayer(
                left, top, left + length, bottom);
        }
 
        if (drawRight) {
            rightSaveCount = canvas.saveUnclippedLayer(
                right - length, top, right, bottom);
        }
    } else {
        scrollabilityCache.setFadeColor(solidColor);
    }
 
    // Step 3, draw the content
    onDraw(canvas);
 
    // Step 4, draw the children
    dispatchDraw(canvas);
 
    // Step 5, draw the fade effect and restore layers
    final Paint p = scrollabilityCache.paint;
    final Matrix matrix = scrollabilityCache.matrix;
    final Shader fade = scrollabilityCache.shader;
 
    // must be restored in the reverse order that they were saved
    if (drawRight) {
        matrix.setScale(1, fadeHeight * rightFadeStrength);
        matrix.postRotate(90);
        matrix.postTranslate(right, top);
        fade.setLocalMatrix(matrix);
        p.setShader(fade);
        if (solidColor == 0) {
            canvas.restoreUnclippedLayer(rightSaveCount, p);
        } else {
            canvas.drawRect(right - length, top, right, bottom, p);
        }
    }
 
    if (drawLeft) {
        matrix.setScale(1, fadeHeight * leftFadeStrength);
        matrix.postRotate(-90);
        matrix.postTranslate(left, top);
        fade.setLocalMatrix(matrix);
        p.setShader(fade);
        if (solidColor == 0) {
            canvas.restoreUnclippedLayer(leftSaveCount, p);
        } else {
            canvas.drawRect(left, top, left + length, bottom, p);
        }
    }
 
    if (drawBottom) {
        matrix.setScale(1, fadeHeight * bottomFadeStrength);
        matrix.postRotate(180);
        matrix.postTranslate(left, bottom);
        fade.setLocalMatrix(matrix);
        p.setShader(fade);
        if (solidColor == 0) {
            canvas.restoreUnclippedLayer(bottomSaveCount, p);
        } else {
            canvas.drawRect(left, bottom - length, right, bottom, p);
        }
    }
 
    if (drawTop) {
        matrix.setScale(1, fadeHeight * topFadeStrength);
        matrix.postTranslate(left, top);
        fade.setLocalMatrix(matrix);
        p.setShader(fade);
        if (solidColor == 0) {
            canvas.restoreUnclippedLayer(topSaveCount, p);
        } else {
            canvas.drawRect(left, top, right, top + length, p);
        }
    }
 
    canvas.restoreToCount(saveCount);
 
    drawAutofilledHighlight(canvas);
 
    // Overlay is part of the content and draws beneath Foreground
    if (mOverlay != null && !mOverlay.isEmpty()) {
        mOverlay.getOverlayView().dispatchDraw(canvas);
    }
 
    // Step 6, draw decorations (foreground, scrollbars)
    onDrawForeground(canvas);
 
    if (debugDraw()) {
        debugDrawFocus(canvas);
    }
}

１．调用链路
ViewRootImpl#performDraw -> View#draw

２．draw由下到上的绘制顺序

  • drawBackground 绘制背景
  • save layer (当有水平或垂直fading edges时)
  • onDraw 绘制当前View的内容
  • dispatchDraw 绘制当前View的子View
  • 绘制 fading edges 和 restore layers (当有水平或垂直 fading edges 时)
  • onDrawForeground 绘制前景或滚动条
  • drawDefaultFocusHighlight 绘制获取焦点的 View 的 Focus 高亮

五　常见问题

１．什么时候获取 View 的测量宽高?

private void performTraversals() {
    ......
    performMeasure(childWidthMeasureSpec, childHeightMeasureSpec);
    ......
    performLayout(lp, mWidth, mHeight);
    ......
    if (triggerGlobalLayoutListener) {
        mAttachInfo.mRecomputeGlobalAttributes = false;
        mAttachInfo.mTreeObserver.dispatchOnGlobalLayout();
    }
    ......
    performDraw();
    ......
}

根据 ViewRootImpl#scheduleTraversals 的调用逻辑。dispatchOnGlobalLayout 在 performMeasure -> performLayout 之后调用，通过该回调可以获取到测量的宽高。

App 层可以通过注册 OnGlobalLayoutListener 方式获取

view.getViewTreeObserver().addOnGlobalLayoutListener(new OnGlobalLayoutListener() {
    @Override
    public void onGlobalLayout() {
		// view.getMeasuredWidth()/view.getMeasuredHeight()
		......
    }
});

２．在子线程中可以更新 UI 吗?

在 Activity#onResume 之前，可以在子线程中更新 UI。
checkThread 线程检查是在 ViewRootImpl 的方法中进行的 (如 invalidate 和 requestLayout)
而通过溯源代码，ViewRootImpl 是在 ActivityThread#handleResumeActivity 创建的。在 Activity#onResume 之前 ViewRootImpl 还没创建，所以也不会检查线程和绘制 UI。

@Override
public void requestLayout() {
    if (!mHandlingLayoutInLayoutRequest) {
        checkThread();
        mLayoutRequested = true;
        scheduleTraversals();
    }
}

@Override
public ViewParent invalidateChildInParent(int[] location, Rect dirty) {
    checkThread();
    ......
}

void checkThread() {
    if (mThread != Thread.currentThread()) {
        throw new CalledFromWrongThreadException(
                "Only the original thread that created a" +  
                "view hierarchy can touch its views.");
    }
}
Big Skipper
关注
  • 0
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Android WMS——ViewRootImpl分析（六）
小旭的专栏
10-28 339
Actiivty 中会创建一个 Window 对象。setContentView 方法中的 View 最终也会被添加到 Window 对象中的 DecorView 中，也就是说一个 Window 中对应着一个 View。这个 View 是被 ViewRootImpl 操作的。WindowManager 就是入口。
Android | 理解 ViewRootImpl
345丶
03-21 6517
简介 ViewRootImpl 是 View 的最高层级，是所有 View 的根。ViewRootImpl 实现了 View 和 WindowManager 之间所需要的协议。ViewRootImpl 的创建过程是从 WindowManagerImpl 中开始的。View 的测量，布局，绘制以及上屏，都是从 ViewRootImpl 中开始的。 我们通过一张图来认识一下它： Window 我们知道界面中所有的元素都是由 View 构成的，View 是依附于 Window 上面的。Window 只是一个
ViewRootImpl简析
wangsheng5454的博客
07-16 1630
ViewRootImpl是视图结构的顶层，实现了视图和WM通信的协议。很大程度上是WindowManagerGlobal的内部实现细节。ViewRootImpl不仅是视图和WM沟通的桥梁，也是事件分发的桥梁。
Android ViewRootImpl
最新发布
liuning1985622的博客
05-04 729
ViewRootImpl 是 View 的最高层级，是所有 View 的根。ViewRootImpl 实现了 View 和 WindowManager 之间所需要的协议。ViewRootImpl 的创建过程是从 WindowManagerImpl 中开始的。View 的测量，布局，绘制以及上屏，都是从 ViewRootImpl 中开始的。
ViewRootImpl介绍
四月葡萄的博客
02-27 2709
1. 简介 从上一篇文章:从setContentView揭开DecorView 中可以看到，Activity是怎么将我们的布局加载到DecorView，但是这时还不是可见的，因为这时布局还没有绘制。那么它是怎么绘制的，我们来研究一下。 本文源码基于android 27 2. 源码分析 虽然DecorView已经被创建出来了，但是目前DecorView跟PhoneWindow是没有任何关
ViewRootImpl的独白，我不是一个View(布局篇)
stven_king的专栏
12-11 1万+
前言前一段时间写过两篇关于View的文章 Activity中的Window的setContentView 和 遇见LayoutInflater&Factory 。分析了Activity设置页面布局到页面View元素进行布局到底经历了一个怎么样的过程？
Android 进阶——图形显示系统之ViewRootImpl对象创建详解(三)
最美不过，心中有梦，身旁有你！
10-20 352
ViewRootImpl 作为顶层视图结构包装类持有IWindowSession、Choreographer 及其Choreographer.FrameCallback接口，主要负责通过IWindowSession与WindowManagerService通信。
Android View源码解读 DecorView与ViewRootImpl浅谈
08-31
ViewRootImpl是Android UI系统的关键组件，它是Activity与系统窗口管理器之间的桥梁。当DecorView被设置后，ViewRootImpl会被创建并绑定到DecorView。ViewRootImpl负责接收系统的事件，如触摸事件、键盘事件，并将...
Android任务管理器源码.zip
03-01
通过深入分析这些源码，我们可以理解Android如何高效地管理众多应用的执行，以及如何在有限的资源下优化用户体验。同时，这也有助于开发者编写更符合系统规范的应用，避免不必要的性能问题和内存泄漏。对Android任务...
Android窗口抖动（源码）.zip
07-03
在Android系统中，窗口抖动（Window ...通过深入研究提供的源码，我们可以更有效地理解和解决Android窗口抖动问题，提升应用的用户体验。在实际项目中，应结合各种调试和优化工具，持续优化代码，确保应用的流畅运行。
Android中Window的管理深入讲解
08-25
Android 中 Window 管理深入讲解 Android 中的 Window 管理是 Android 开发中非常重要...Android 中的 Window 管理是非常复杂的，需要深入理解 Window 和 WindowManager 的关系，以及 Window 的 flags 等属性的使用。
Android应用源码之窗口抖动（源码）.zip
10-14
下面，我们将深入探讨Android窗口抖动的相关知识点，并结合源码来理解如何避免和优化这种情况。 1. **UI刷新机制**： Android系统的UI更新是基于消息队列和主线程（UI线程）的。通过`ViewRootImpl`中的`...
Android ViewRootImpl 解析
lerendan的博客
04-17 4506
一、前言 本篇文章我们来详细分析一下 ViewRootImpl。 二、View 通过 ViewRootImpl 来绘制 ViewRootImpl 是一个视图层次结构的顶部，在上一篇文章中我们知道了 ViewRootImpl 实现了 View 与 WindowManager 之间所需要的协议，作为 WindowManagerGlobal 中大部分的内部实现。这个好理解，在 Window...
Android事件分发机制（一）——ViewRootImpl篇
Flying snow
11-09 3387
我们都知道View事件的分发顺序是Activity—&amp;amp;amp;gt;Window—&amp;amp;amp;gt;View。 //Activity public boolean dispatchTouchEvent(MotionEvent ev) { if (ev.getAction() == MotionEvent.ACTION_DOWN) { onUserInteraction(); ...
温故知新：探究Android UI 绘制刷新流程
maniuT的博客
11-09 406
这就是我遇到的问题：单纯的根据TextView在子线程可以更新得出的结论，总的来说要想不崩溃还得绕过中的的检测。至于研究它有什么用，只有知道理解源码的流程，才能写出更好的东西。
从ViewRootImpl类分析View绘制的流程
热门推荐
废墟的树的专栏
07-09 1万+
【转载请注明出处：从ViewRootImpl类分析View绘制的流程 CSDN 废墟的树】从上两篇博客 《从setContentView方法分析Android加载布局流程》 和 《从LayoutInflater分析XML布局解析成View的树形结构的过程》 中我们了解到Activity视图UI是怎么添加到Activity的根布局DecorView上面的。我们知道Activity中的PhoneVie
Android-View源码解读：浅谈DecorView与ViewRootImpl
m0_70083062的博客
05-08 375
这里先梳理一下以上的内容：Activity通过PhoneWindow的setContentView方法来设置布局，而设置布局之前，会先判断是否存在mContentParent，而我们设置的布局文件则是mContentParent的子元素。 创建DecorView 接着上面提到的installDecor()方法，我们看看它的源码， PhoneWindow#installDecor： private void installDecor() { if (mDecor == null) { mDecor = gen
Android渲染原理必知必会-ViewRootImpl类核心解析
在路上-codingAndlearning
02-22 1861
了解ViewRootImpl是学习Android UI机制的核心：事件分发机制，view绘制原理
androidP: View的工作原理-初识ViewRoot和DecorView
zhuowalun8427的博客
03-01 241
参考链接： Activity、Window、DecorView与ViewRoot之间的关系 ： https://blog.csdn.net/m0_37698652/article/details/101381021?spm=1001.2101.3001.6661.1&utm_medium=distribute.pc_relevant_t0.none-task-blog-2%7Edefault%7ECTRLIST%7ERate-1.pc_relevant_paycolumn_v3&depth_
Android旅游管理系统需求分析
"基于Android的旅游管理系统需求分析.pdf" 这篇文档主要介绍了基于Android平台的旅游管理系统的需求分析。系统旨在为旅游爱好者和Android手机用户提供便捷的旅游信息管理与服务。以下是详细内容： 1. 目的 这份...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值