继续浏览精彩内容
慕课网APP
程序员的梦工厂
打开
继续
感谢您的支持,我会继续努力的
赞赏金额会直接到老师账户
将二维码发送给自己后长按识别
微信支付
支付宝支付

Android中View的绘制流程

小怪兽是程序员
关注TA
已关注
手记 5
粉丝 3
获赞 33

安卓view的绘制流程主要分为三个阶段:

一、测量过程(mesure)

二、确定子元素的过程(layout)

三、绘制过程(draw)

我们在activity的oncread方法中会使用setContentView来填充一个布局

public void setContentView(@LayoutRes int layoutResID) { 

getWindow().setContentView(layoutResID); initWindowDecorActionBar(); 

}

这个getWindow方法是获取的PhoneWindow,然后调用它的setContentView方法,在此方法中,会调用generateDecor()方法,方法体如下:

protected DecorView generateDecor() { 
    return new DecorView(getContext(), -1);
 }

在此方法中会实例化一个decorview的东西,那么它是什么东西呢?其实decorview是整个view树的最顶层view,有一个子LinearLayout,代表整个Window界面,包含通知栏,标题栏,内容显示栏三块区域,我们setcontentview的布局就是这个内容区域,所以说,DecorView是我们的顶层布局。

到此,我们已经 加载了布局,但是还没有经过测量等的步骤,所以还无法显示布局界面,接下来安卓需要做的是把decorview加载到window,并且进行测量等工作。

那么decorview是如何加载到window中呢?

在activity创建的时候,UI线程会调用handleResumeActivity方法,此方法中会获取该activity所关联的window,DecorView和windowManager,具体代码如下:

if (r.window == null && !a.mFinished && willBeVisible) {

     r.window = r.activity.getWindow(); 

     View decor = r.window.getDecorView(); 

     decor.setVisibility(View.INVISIBLE);

     ViewManager wm = a.getWindowManager(); 

     WindowManager.LayoutParams l = r.window.getAttributes();

     a.mDecor = decor;

    l.type = WindowManager.LayoutParams.TYPE_BASE_APPLICATION; 

    l.softInputMode |= forwardBit; 

    if (a.mVisibleFromClient) { 

    a.mWindowAdded = true; wm.addView(decor, l); 

    }

windowManager的实现类中,会实例化一个ViewRootImpl的类,此时会把decorview传入ViewRootImpl对象,代码如下:

root = new ViewRootImpl(view.getContext(), display);

root.setView(view, wparams, panelParentView);

在setview方法中,会调用WindowManagerService将decorview添加到window中,然后WindowManagerService调用ViewRootImpl的performTraverals方法开始进行测量、布局、绘制流程,可以说,现在才真正开始绘制布局,ViewRootImpl是连接WindowManager和DecorView的桥梁,测量、布局、绘制都是通过ViewRootImpl来进行的。

ViewRootImpl和MeasureSpec

我们通过查看ViewRootImpl类发现,此类有7511行代码,我们挑重点看,

mesure、layout、draw的发起者都是performTraversals方法,接下来我们来查看下此方法的代码:

if (!mStopped || mReportNextDraw) {
                boolean focusChangedDueToTouchMode = ensureTouchModeLocally(
                        (relayoutResult&WindowManagerGlobal.RELAYOUT_RES_IN_TOUCH_MODE) != 0);
                if (focusChangedDueToTouchMode || mWidth != host.getMeasuredWidth()
                        || mHeight != host.getMeasuredHeight() || contentInsetsChanged ||
                        updatedConfiguration) {
                    int childWidthMeasureSpec = getRootMeasureSpec(mWidth, lp.width);
                    int childHeightMeasureSpec = getRootMeasureSpec(mHeight, lp.height);
                    ......
                     // Ask host how big it wants to be
                    performMeasure(childWidthMeasureSpec, childHeightMeasureSpec);
                    ......
                    if (measureAgain) {
                       ......
                        performMeasure(childWidthMeasureSpec, childHeightMeasureSpec);
                    }
                    layoutRequested = true;
                }
            }
        } else {
           ......
        }

//performLayout
if (didLayout) {
            performLayout(lp, mWidth, mHeight);

            ......
        }

//performDraw
if (!cancelDraw && !newSurface) {
            if (mPendingTransitions != null && mPendingTransitions.size() > 0) {
                for (int i = 0; i < mPendingTransitions.size(); ++i) {
                    mPendingTransitions.get(i).startChangingAnimations();
                }
                mPendingTransitions.clear();
            }

            performDraw();
        } else {
            ......
        }

通过以上代码可以发现childWidthMeasureSpec和childHeightMeasureSpec 两个属性,这两个数是一个32位的整型数,高2位表示的是测量模式,剩余30位表示的是对应测量模式下的大小。

我们去getRootMeasureSpec这个方法里看一下:

private static int getRootMeasureSpec(int windowSize, int rootDimension) {
        int measureSpec;
        switch (rootDimension) {
        case ViewGroup.LayoutParams.MATCH_PARENT:
            // Window can't resize. Force root view to be windowSize.
            measureSpec = MeasureSpec.makeMeasureSpec(windowSize, MeasureSpec.EXACTLY);
            break;
        case ViewGroup.LayoutParams.WRAP_CONTENT:
            // Window can resize. Set max size for root view.
            measureSpec = MeasureSpec.makeMeasureSpec(windowSize, MeasureSpec.AT_MOST);
            break;
        default:
            // Window wants to be an exact size. Force root view to be that size.
            measureSpec = MeasureSpec.makeMeasureSpec(rootDimension, MeasureSpec.EXACTLY);
            break;
        }
        return measureSpec;
}

调用了MeasureSpec的方法得到的这两个值,MeasureSpec是View里的一个静态内部类:

public static class MeasureSpec {

        private static final int MODE_SHIFT = 30;

        private static final int MODE_MASK  = 0x3 << MODE_SHIFT;

        /** @hide */

        @IntDef({UNSPECIFIED, EXACTLY, AT_MOST})

        @Retention(RetentionPolicy.SOURCE)

        public @interface MeasureSpecMode {}

        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

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

            }

        }

        public static int makeSafeMeasureSpec(int size, int mode) {

            if (sUseZeroUnspecifiedMeasureSpec && mode == UNSPECIFIED) {

                return 0;

            }

            return makeMeasureSpec(size, mode);

        }

        @MeasureSpecMode

        public static int getMode(int measureSpec) {

            //noinspection ResourceType

            return (measureSpec & MODE_MASK);

        }

        public static int getSize(int measureSpec) {

            return (measureSpec & ~MODE_MASK);

        }

        static int adjust(int measureSpec, int delta) {

            final int mode = getMode(measureSpec);

            int size = getSize(measureSpec);

            if (mode == UNSPECIFIED) {

                // No need to adjust size for UNSPECIFIED mode.

                return makeMeasureSpec(size, UNSPECIFIED);

            }

            size += delta;

            if (size < 0) {

                Log.e(VIEW_LOG_TAG, "MeasureSpec.adjust: new size would be negative! (" + size +

                        ") spec: " + toString(measureSpec) + " delta: " + delta);

                size = 0;

            }

            return makeMeasureSpec(size, mode);

        }

        public static String toString(int measureSpec) {

            int mode = getMode(measureSpec);

            int size = getSize(measureSpec);

            StringBuilder sb = new StringBuilder("MeasureSpec: ");

            if (mode == UNSPECIFIED)

                sb.append("UNSPECIFIED ");

            else if (mode == EXACTLY)

                sb.append("EXACTLY ");

            else if (mode == AT_MOST)

                sb.append("AT_MOST ");

            else

                sb.append(mode).append(" ");

            sb.append(size);

            return sb.toString();

        }

}

可以看到,它有三种测量模式,UNSPECIFIED,EXACTLY和AT_MOST,三种模式分别代表的含义:

UNSPECIFIED:不指定测量模式,父视图没有限制子视图的大小,子视图可以使想要的任何尺寸,通常这个模式在开发中用不到,日常开发中,必然会根据父视图去限制子视图的大小

EXACTLY:精确测量模式,当该视图的宽高指定为确定数值或者match_parent时生效,表示父视图已经决定了子视图的大小,测量出来的值其实就是设置的数值

AT_MOST:最大值模式,当该视图的宽高为wrap_content时生效,此时只要子视图的尺寸在父视图允许的最大范围都可以,常见的情况比如:需要在ScrollView中嵌套ListView,此时如果不重写listview的测量模式为AT_MOST,则会出现listview只显示一行的情况
至此,测量之前的工作基本分析完毕。

View的Measure过程

现在我们开始进行mesure的过程,查看performMeasure源码如下:

private void performMeasure(int childWidthMeasureSpec, int childHeightMeasureSpec) {

        Trace.traceBegin(Trace.TRACE_TAG_VIEW, "measure");

        try {

            mView.measure(childWidthMeasureSpec, childHeightMeasureSpec);

        } finally {

            Trace.traceEnd(Trace.TRACE_TAG_VIEW);

        }

}

通过代码我们发现,测量开始,是调用了mView的mesure方法,这个mview是WindowManager中实例化ViewRootImpl后调用setView传进来的DecorView,所以说,测量是通过父View往子View进行的过程

接下来看下ViewGroup中是怎么把measure分发给各个子View的:

protected void measureChildren(int widthMeasureSpec, int heightMeasureSpec) {

        final int size = mChildrenCount;

        final View[] children = mChildren;

        for (int i = 0; i < size; ++i) {

            final View child = children[i];

            if ((child.mViewFlags & VISIBILITY_MASK) != GONE) {

                measureChild(child, widthMeasureSpec, heightMeasureSpec);

            }

        }

}

以上代码很容易理解,用循环的方式挨个measureChild来进行的,继续看measureChild的源码:

protected void measureChild(View child, int parentWidthMeasureSpec,

            int parentHeightMeasureSpec) {

        final LayoutParams lp = child.getLayoutParams();

        final int childWidthMeasureSpec = getChildMeasureSpec(parentWidthMeasureSpec,

                mPaddingLeft + mPaddingRight, lp.width);

        final int childHeightMeasureSpec = getChildMeasureSpec(parentHeightMeasureSpec,

                mPaddingTop + mPaddingBottom, lp.height);

        child.measure(childWidthMeasureSpec, childHeightMeasureSpec);

}

子View获取childWidthMeasureSpec 和childHeightMeasureSpec 后,继续调用自身的measure方法,我们继续跟踪,在view的measure方法中,有如下一个方法:

onMeasure(widthMeasureSpec, heightMeasureSpec);

由于view的measure为final方法,所以当我们自定义控件时,系统为我们准备都得覆盖方法就是上边的onMeasure方法,onMeasure里有两行代码:

protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {

        setMeasuredDimension(getDefaultSize(getSuggestedMinimumWidth(), widthMeasureSpec),

                getDefaultSize(getSuggestedMinimumHeight(), heightMeasureSpec));

    }

setMeasuredDimension用于设置View测量的宽和高,getDefaultSize表示,如果View没有重新onmeasure方法,则会直接获取默认的宽和高,这里把getDefaultSize当作参数直接传给setMeasuredDimension,就是为了防止view没有重写onMeasure方法。

getDefaultSize的代码 如下:

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;

    }

至此,测量的基本流程已进行完毕,由于layout和draw过程相对简单,本篇将不再讨论

打开App,阅读手记
5人推荐
发表评论
随时随地看视频慕课网APP