Android View绘制流程

最新推荐文章于 2024-04-01 04:19:42 发布

Mr_LiaBin

最新推荐文章于 2024-04-01 04:19:42 发布

阅读量864

点赞数

分类专栏： Android开发文章标签： android view

本文链接：https://blog.csdn.net/Mr_LiaBill/article/details/49128531

版权

Android开发专栏收录该内容

63 篇文章 0 订阅

订阅专栏

总结

每一个视图的绘制过程都必须经历三个最主要的阶段，即onMeasure() 测量、onLayout() 布局和onDraw() 绘制，下面我们逐个对这三个阶段展开进行探讨。

PhoneWindow的setContentView方法源码

    @Override
    public void setContentView(View view, ViewGroup.LayoutParams params) {
        ......
        //如果mContentParent为空进行一些初始化，实质mContentParent是通过findViewById(ID_ANDROID_CONTENT);获取的id为content的FrameLayout的布局（不清楚的请先看《Android应用setContentView与LayoutInflater加载解析机制源码分析》文章）
        if (mContentParent == null) {
            installDecor();
        } 
        ......
        //把我们的view追加到mContentParent
        mContentParent.addView(view, params);
        ......
    }

ViewGroup的addView方法

    public void addView(View child) {
        addView(child, -1);
    }

    public void addView(View child, int index) {
        ......
        addView(child, index, params);
    }

    public void addView(View child, int index, LayoutParams params) {
        ......
        //该方法稍后后面会详细分析
        requestLayout();
        //重点关注！！！
        invalidate(true);
        ......
    }

当我们写一个Activity时，我们一定会通过setContentView方法将我们要展示的界面传入该方法，该方法会讲我们界面通过addView追加到id为content的一个FrameLayout（ViewGroup）中，然后addView方法中通过调运invalidate(true)去通知触发ViewRootImpl类的performTraversals()方法，至此递归绘制我们自定义的所有布局

因为调用了添加view的时候调用了invalidate(true)方法，invalidate实际上就会调用ViewRootImpl的performTraversals方法。invalidate怎么就执行到了performTraversals方法，可以参考 Android视图状态及重绘流程分析，带你一步步深入了解View(三)

performTraversals方法中有，一开始绘制的肯定是DecorView，因为这是窗口的根View。。。。

    int childWidthMeasureSpec = getRootMeasureSpec(mWidth, lp.width);
    int childHeightMeasureSpec = getRootMeasureSpec(mHeight, lp.height);

    //第一阶段测量，最后调用了measure(childWidthMeasureSpec, childHeightMeasureSpec)方法
    performMeasure(childWidthMeasureSpec, childHeightMeasureSpec);
					
	private void performMeasure(int childWidthMeasureSpec, int childHeightMeasureSpec) {
        Trace.traceBegin(Trace.TRACE_TAG_VIEW, "measure");
        try {
            mView.measure(childWidthMeasureSpec, childHeightMeasureSpec);//从最外层的viewgroup开始测量
        } finally {
            Trace.traceEnd(Trace.TRACE_TAG_VIEW);
        }
    }
	
	//第二阶段测量，最后调用了layout方法
	performLayout(lp, desiredWindowWidth, desiredWindowHeight);
	private void performLayout(WindowManager.LayoutParams lp, int desiredWindowWidth,
            int desiredWindowHeight) {
        mLayoutRequested = false;
        mScrollMayChange = true;
        mInLayout = true;

        final View host = mView;
        if (DEBUG_ORIENTATION || DEBUG_LAYOUT) {
            Log.v(TAG, "Laying out " + host + " to (" +
                    host.getMeasuredWidth() + ", " + host.getMeasuredHeight() + ")");
        }

        Trace.traceBegin(Trace.TRACE_TAG_VIEW, "layout");
        try {
            host.layout(0, 0, host.getMeasuredWidth(), host.getMeasuredHeight());//从最外层的viewgroup开始布局
	    ..........
	    }
        ..........
	}
	
	//第三阶段测量，最后调用了draw(canvas)方法
	performDraw();
	private void performDraw() {
        if (mAttachInfo.mDisplayState == Display.STATE_OFF && !mReportNextDraw) {
            return;
        }

        final boolean fullRedrawNeeded = mFullRedrawNeeded;
        mFullRedrawNeeded = false;

        mIsDrawing = true;
        Trace.traceBegin(Trace.TRACE_TAG_VIEW, "draw");
        try {
            draw(fullRedrawNeeded);//从最外层的viewgroup开始绘制
	    .....
	    }
	......
	}

Measure()

调用了onMeasure()方法，这里才是真正去测量并设置View大小的地方

当然，一个界面的展示可能会涉及到很多次的measure，因为一个布局中一般都会包含多个子视图，每个视图都需要经历一次measure过程。
ViewGroup中定义了一个 measureChildren()方法来去测量子视图的大小.这里首先会去遍历当前布局下的所有子视图，然后逐个调用measureChild()方法来测量相应子视图的大小

    @Override  
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {  
        setMeasuredDimension(200, 200);  
    }

这样的话就把View默认的测量流程覆盖掉了，不管在布局文件中定义MyView这个视图的大小是多少，最终在界面上显示的大小都将会是200*200。

首先getMeasureWidth()方法在measure()过程结束后就可以获取到了，而getWidth()方法要在layout()过程结束后才能获取到。
另外， getMeasureWidth()方法中的值是通过setMeasuredDimension()方法来进行设置的，而getWidth()方法中的值则是通过视图右边的坐标减去左边的坐标计算出来的。

流程：

ViewGroup测量所有子view

protected void measureChildren(int widthMeasureSpec, int heightMeasureSpec) {//widthMeasureSpec,heightMeasureSpec是viewgroup的
    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方法

protected void measureChild(View child, int parentWidthMeasureSpec,
        int parentHeightMeasureSpec) {
    final LayoutParams lp = child.getLayoutParams();
	//parentWidthMeasureSpec是当前ViewGroup的MeasureSpec
    final int childWidthMeasureSpec = getChildMeasureSpec(parentWidthMeasureSpec,
            mPaddingLeft + mPaddingRight, lp.width);
    final int childHeightMeasureSpec = getChildMeasureSpec(parentHeightMeasureSpec,
            mPaddingTop + mPaddingBottom, lp.height);
    child.measure(childWidthMeasureSpec, childHeightMeasureSpec);
	//调用子view的measure方法childWidthMeasureSpec，childHeightMeasureSpec都是通过ViewGroup中的getChildMeasureSpec方法得到的，
	//综合了ViewGroup的padding，子view的LayoutParams参数等
}

//根据viewgroup的spec大小，还有设置的padding，同时还要view中设置的layoutParam参数得到当前子view的spec大小
public static int getChildMeasureSpec(int spec, int padding, int childDimension) {
        int specMode = MeasureSpec.getMode(spec);
        int specSize = MeasureSpec.getSize(spec);

        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) {
                resultSize = childDimension;
                resultMode = MeasureSpec.EXACTLY;
            } else if (childDimension == LayoutParams.MATCH_PARENT) {
                // Child wants to be our size. So be it.
                resultSize = size;
                resultMode = MeasureSpec.EXACTLY;
            } else if (childDimension == LayoutParams.WRAP_CONTENT) {
                // Child wants to determine its own size. It can't be
                // bigger than us.
                resultSize = size;
                resultMode = MeasureSpec.AT_MOST;
            }
            break;

        // Parent has imposed a maximum size on us
        case MeasureSpec.AT_MOST:
            if (childDimension >= 0) {
                // Child wants a specific size... so be it
                resultSize = childDimension;
                resultMode = MeasureSpec.EXACTLY;
            } else if (childDimension == LayoutParams.MATCH_PARENT) {
                // Child wants to be our size, but our size is not fixed.
                // Constrain child to not be bigger than us.
                resultSize = size;
                resultMode = MeasureSpec.AT_MOST;
            } else if (childDimension == LayoutParams.WRAP_CONTENT) {
                // Child wants to determine its own size. It can't be
                // bigger than us.
                resultSize = size;
                resultMode = MeasureSpec.AT_MOST;
            }
            break;
		return MeasureSpec.makeMeasureSpec(resultSize, resultMode);
}

getChildMeasureSpec(parentWidthMeasureSpec, mPaddingLeft + mPaddingRight, lp.width);

可以看到子view的大小由padding，父视图，子视图共同决定。。。

child.measure(childWidthMeasureSpec, childHeightMeasureSpec);

说明子view的Spec都是从父view传下来的。

而测量子View大小的时候，measure会调用onmeasure

protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) { //所以如果重写了view的onmeasure方法，那么widthMeasureSpec/heightMeasureSpec都是上一级的ViewGroup给出的
    setMeasuredDimension(getDefaultSize(getSuggestedMinimumWidth(), widthMeasureSpec),
        getDefaultSize(getSuggestedMinimumHeight(), heightMeasureSpec));
}
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;
}

setMeasuredDimension才是真正的测量大小的方法。

getSuggestedMinimumHeight: 返回这个view的最小高度，在minHeight和背景图片的最小高度中取大值。
    /* Returns the suggested minimum height that the view should use. This
     * returns the maximum of the view's minimum height
     * and the background's minimum height*/

getDefaultSize中可以知道，当是UNSPECIFIED使用的是getSuggestedMinimumHeight，当是AT_MOST EXACTLY时使用的是specSize

MeasureSpec.makeMeasureSpec(resultSize, resultMode);可以返回widthMeasureSpec

运行过程中获取view大小

因为view只有在onlayout调用结束之后，才能去赋值width,height。所以如果在oncreate中，此时屏幕还没绘制出来，就去getWidth，getHeight得到的结果是0。可以通过如下方式获取view实际的大小

        //Register a callback to be invoked when the global layout state or the visibility of views within the view tree changes
        image.getViewTreeObserver().addOnGlobalLayoutListener(new ViewTreeObserver.OnGlobalLayoutListener() {
            @Override
            public void onGlobalLayout() {
                //image.getViewTreeObserver().removeGlobalOnLayoutListener(this);
                int height = image.getHeight();
                int width = image.getWidth();
                Log.d(TAG, "width:" + width + " height:" + height);
            }
        });

最后：

MATCH_PARENT和具体数值 --》EXACTLY

WRAP_CONTENT --》AT_MOST

Layout()

通过调用子view的layout方法中计算出来的
视图大小的控制是由父视图、布局文件、以及视图本身共同完成的，父视图会提供给子视图参考的大小，
而开发人员可以在XML文件中指定视图的大小，然后视图本身会对最终的大小进行拍板。

layout()方法接收四个参数，分别代表着左、上、右、下的坐标，当然这个坐标是相对于当前视图的父视图而言的。这里可以通过上面measure过程中得到getMeasureWidth和getMeasureHeight得到的宽高来布局，或者完全不使用也可以的。默认实现layout的时候layout（left,top,left+getMeasureWidth,top+getMeasureHeight)都是用到了。

接着调用了onLayout方法
因为onLayout()过程是为了确定view在布局中所在的位置，而这个操作应该是由布局来完成的，即父视图决定子视图的显示位置。
既然如此，我们来看下ViewGroup中的onLayout()方法是怎么写的吧，代码如下：
@Override
protected abstract void onLayout(boolean changed, int l, int t, int r, int b);

可以看到，ViewGroup中的onLayout()方法竟然是一个抽象方法，这就意味着所有ViewGroup的子类都必须重写这个方法。没错，像LinearLayout、RelativeLayout等布局，
都是重写了这个方法，然后在内部按照各自的规则对子视图进行布局的。

所以如果要自定义ViewGroup并实现自己的布局，就需要实现onLayout方法，把该ViewGroup中所有的childView正确的布局起来
调用child.layout(mLeft, mTop, mRight, mBottom); 注意这里是layout方式，区分与onLayout方法

getTop getLeft getRight getBottom分别就是上面设置的值
    public final int getWidth() {
        return mRight - mLeft;
    }
   public final int getLeft() {
        return mLeft;
    }
mRight等值在layout()方法中赋值的

Draw()

         /*
         * Draw traversal performs several drawing steps which must be executed
         * in the appropriate order:
         *
         *      1. Draw the background //绘制背景
         *      2. If necessary, save the canvas' layers to prepare for fading
         *      3. Draw view's content 绘制当前view的内容，调用onDraw(canvas);
         *      4. Draw children   如果当前view是viewgroup实例，那么就会去遍历绘制子view，调用dispatchDraw(canvas); 接着调用drawChild，最后执行了child.draw(canvas, this, drawingTime);
         *      5. If necessary, draw the fading edges and restore layers
         *      6. Draw decorations (scrollbars for instance) 绘制滚动条
         */

       调用onDraw绘制view本身
       dispatchDraw(canvas)绘制子view，最后会调用子view的Draw()方法

invalidate()方法虽然最终会调用到DecorView的performTraversals()方法中(但是为什么只会调用该view的Draw方法，而不会调用该view所在的viewgroup的Draw方法？同时如果对view设置动画或者scroll滚动同样调用invaildate但是设置了标志位，但是为什么重绘的是view所在的viewgroup？)，但这时measure和layout流程是不会重新执行的，因为视图没有强制重新测量的标志位，而且大小也没有发生过变化，所以这时只有draw流程可以得到执行。一定要注意此时只有该view的Draw方法得到调用。而如果你希望视图的绘制流程可以完完整整地重新走一遍，就不能使用invalidate()方法，而应该调用requestLayout()了。
postInvalidate()，可以在非UI线程中直接调用，刷新view，其实原理就是这个方法内部使用了handler而已，发消息到UI线程。

参考

1.Android应用层View绘制流程与源码分析

自定义属性

构造函数

自定义view过程中除了需要根据需要重写onMeasure，onLaout，onDraw之外。最必不可少的还是重写构造函数。

构造函数

//如果需要能够在Code中实例化一个View，必须重写

    public MyView(Context context) {
        this(context,null);
    }
    //如果需要在xml中定义，必须重写这个带attrs属性的构造函数，这个attr中包括了xml中view定义的所有属性，包括自定义属性
    public MyView(Context context, AttributeSet attrs) {
        this(context, attrs,0);
    }

//这个方法并不会主动调用，defStyleAttr表示在theme中定义的属性，如果xml中没有找到，或者style中没有找到，就会使用这个默认。0表示不在theme中查找

public MyView(Context context, AttributeSet attrs, int defStyleAttr) {
super(context, attrs, defStyleAttr);

}

xml中自定义属性

在attrs.xml中定义

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <attr name="customeTest" format="reference"></attr>

    <declare-styleable name="test">
        <attr name="name" format="string"/>
    </declare-styleable>
</resources>

此时在生成了两个attrs，不管attrs有没有定义在declare-styleable中，name属性是string类型，customeTest属性是一个引用类型，还有其它几种类型，不一一列举。

public static final class attr {
    public static final int CustomeTest=0x7f010004;
    public static final int name=0x7f010000;

}

不同的是，如果声明在declare-styleable中，系统还会为我们在R.styleable中生成相关的属性。

public static final class styleable {
    public static final int[] test= {
        0x7f010000
    };
    public static final int test_name = 0;

}

此时test数组的元素其实就是R.attrs.name的值

xml中获取自定义属性

只需要加一行，xmlns:app="http://schemas.android.com/apk/res-auto"，所有自定义的属性都是在app这个域中

    <lbb.mytest.demo.MyView
        android:layout_width="0dp"
        android:layout_height="0dp"
        app:name="haha"
    >

android:开头的，说明是系统自定义的属性，app开头是自定义属性

代码中获取自定义属性

    public MyView(Context context, AttributeSet attrs) {
        this(context, attrs, R.attr.customeTest);
    }

    public MyView(Context context, AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
        
        TypedArray typedArray = context.obtainStyledAttributes(attrs, R.styleable.test, defStyleAttr, R.style.styleTest);
        String name = typedArray.getString(R.styleable.test_name);//R.styleable.test_name为0，说明是上面数组的一个元素
        Log.d(TAG, "name = " + name);

        typedArray.recycle();
    }

此时注意

defStyleAttr - An attribute in the current theme that contains a reference to a style resource that supplies defaults values for the TypedArray. Can be 0 to not look for defaults.

此时说明defStyleAttr是一个目前主题中的属性，这个属性其实是一个引用类型，引导style，如果是0的话，就不在theme主题中查找了。

defStyleRes - A resource identifier of a style resource that supplies default values for the TypedArray, used only if defStyleAttr is 0 or can not be found in the theme. Can be 0 to not look for defaults.

此时说明defStyleRes是一个style，只有在defStyleAttr为0或者在theme中找不到这个attrs的时候才生效

1. obtainStyledAttributes方法的第二个参数是Int[]数组，所以可以方便的引用R.styleable.** 当然也可以自己写，不过麻烦

2. obtainStyledAttributes方法第三个参数defStyleAttr为0或Theme中没有定义defStyleAttr时，第四个参数defStyleRes才起作用，这句话怎么理解，看下面示例代码

如果要获取该view所有的属性，包括系统属性

        int count = attrs.getAttributeCount();
        for (int i = 0; i < count; i++) {
            String attrName = attrs.getAttributeName(i);
            String attrVal = attrs.getAttributeValue(i);
            Log.e(TAG, "attrName = " + attrName + " , attrVal = " + attrVal);
        }

此时layout_width layout_height都会打印出来

属性优先级

直接在XML中定义 > style定义 > 由defStyleAttr定义的值 > defStyleRes指定的默认值

代码示例

attrs.xml

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <attr name="customeTest" format="reference"></attr>

    <declare-styleable name="test">
        <attr name="name" format="string"/>
    </declare-styleable>
</resources>

这里定义了两个属性，其实customeTest可以当obtainStyledAttributes方法的第三个参数defStyleAttr使用

style.xml文件

<resources>
    <!-- Base application theme. -->
    <style name="AppTheme" parent="Theme.AppCompat.Light.DarkActionBar">
        <!-- Customize your theme here. -->
        <item name="customeTest">@style/defTest</item>
    </style>

    <style name="xmlStyleTest">
        <item name="name">name in xmlStyleTest</item>
    </style>

    <style name="defTest">
        <item name="name">name in defTest</item>
    </style>

    <style name="styleTest">
        <item name="name">name in styleTest</item>
    </style>
</resources>

整个应用的主题是AppTheme，AppTheme中定义了customeTest属性，并引用了defTest这个style

自定义View

public class MyView extends View {
    private String TAG = "LiaBin";

    public MyView(Context context) {
        this(context, null);
    }

    public MyView(Context context, AttributeSet attrs) {
        this(context, attrs, R.attr.customeTest);
    }

    public MyView(Context context, AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
        TypedArray typedArray = context.obtainStyledAttributes(attrs, R.styleable.test, defStyleAttr, R.style.styleTest);
        String name = typedArray.getString(R.styleable.test_name);
        Log.d(TAG, "name = " + name);

        typedArray.recycle();
    }

}

this(context, attrs, R.attr.customeTest);//注意这里必须是R.attr.customeTest，同时这个属性必须在theme中覆盖才会生效。
context.obtainStyledAttributes(attrs, R.styleable.test, defStyleAttr, R.style.styleTest);//R.style.styleTest要生效，除非R.attr.customeTest在AppTheme主题中没定义或者为0

主界面代码

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
              xmlns:app="http://schemas.android.com/apk/res-auto"
              android:layout_width="match_parent"
              android:layout_height="match_parent"
              android:gravity="center">

    <lbb.mytest.demo.MyView
        style="@style/xmlStyleTest"
        android:layout_width="100dp"
        android:layout_height="100dp"
        android:background="#770000ff"
        app:name="name in xml"/>

</LinearLayout>

1. 最后肯定打印，"name in xml“　xml中优先级最高

2. 如果没有app:name="name in xml" 那么打印”name in xmlStyleTest“ 意味xml中定义的style属性优先级其次，

3. 如果app:name="name in xml" style="@style/xmlStyleTest"都没有，那么就打印“name in defTest” 因为AppTheme中定义了R.attr.customeTest并引用了defTest这个style

4. 只有当 <style name="AppTheme" parent="Theme.AppCompat.Light.DarkActionBar" />当前主题中把customeTest属性去掉，才会使用R.style.styleTest

XML资源引用区别

1. 引用系统定义资源

android:background="@android:color/holo_red_dark"

2. 引用项目中定义的资源

android:background="@color/holo_red_dark"
colors.xml
<?xml version="1.0" encoding="utf-8"?>
<resources>
<color name="holo_red_dark">#ffcc0000</color>
</resources>

3. 引用项目主题中的属性
android:background="?attr/holo_red_dark"
attrs.xml
   <attr name="holo_red_dark" format="reference|color"></attr>
    <style name="AppTheme" parent="Theme.AppCompat.Light.DarkActionBar">
        
        <item name="holo_red_dark">@android:color/holo_red_dark</item>
    </style>

?android:attr/    表示的是引用系统主题中的属性

参考文档

1. Android视图绘制流程完全解析，带你一步步深入了解View(二)

2. 同时配合我前面的博客，《Android Scroll原理分析》《Android LayoutInflater原理分析》

3. Android 深入理解Android中的自定义属性

4. Android中自定义样式与View的构造函数中的第三个参数defStyle的意义

Mr_LiaBin

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Android View绘制流程

Measure()调用了onMeasure()方法，这里才是真正去测量并设置View大小的地方当然，一个界面的展示可能会涉及到很多次的measure，因为一个布局中一般都会包含多个子视图，每个视图都需要经历一次measure过程。ViewGroup中定义了一个measureChildren()方法来去测量子视图的大小.这里首先会去遍历当前布局下的所有子视图，然后逐个调用measur
复制链接

扫一扫