View的三大流程指的是measure(测量)、layout(布局)、draw(绘制)。
下面我们来分别看看这三大流程
View的measure(测量)
MeasureSpec
MeasureSpec是View的一个内部静态类
//view.class
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;
/**
* 精确模式，对应的是match_parent和具体值，比如100dp
public static final int EXACTLY = 1 << MODE_SHIFT;
/**
* 最大模式，对应的就是wrap_content
*/
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);
}
}
/**
* 获取测量的模式
*/
@MeasureSpecMode
public static int getMode(int measureSpec) {
//noinspection ResourceType
return (measureSpec & MODE_MASK);
}
/**
* 获取测量到的尺寸大小
*/
public static int getSize(int measureSpec) {
return (measureSpec & ~MODE_MASK);
}
...
}
MeasureSpec总结起来就是：
- 它由2部分数据组成，分别为定义了View测量的模式和View的测量尺寸大小
- 其中EXACTLY精确模式表示的是match_parent和具体值；AT_MOST最大模式表示的是wrap_content的情况
View的measure过程
View的measure过程由其measure方法完成，在measure方法中会调用View的onMeasure方法
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
setMeasuredDimension(getDefaultSize(getSuggestedMinimumWidth(), widthMeasureSpec),
getDefaultSize(getSuggestedMinimumHeight(), heightMeasureSpec));
}
setMeasuredDimension方法会设置View的测量宽高，所以我们知道getDefaultSize方法返回的就是View的测量宽高。我们来看看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;
//对应的是wrap_content
case MeasureSpec.AT_MOST:
//对应的是match_parent和具体值，返回的是测量值
case MeasureSpec.EXACTLY:
result = specSize;
break;
}
return result;
}
从getDefaultSize方法我们可以看到，无论是测量模式无论是AT_MOST还是EXACTLY，返回的结果都是specSize这个测量后的大小。当View的测量模式是AT_MOST，也就是我们在布局中给View设置的是wrap_content时，这个specSize实际上是父容器中的可用大小，也就相当于是和match_parent是一样的效果了。所以我们在通过继承View来自定义View时，就需要特别处理wrap_content的情况。
ViewGroup的measure过程
对于ViewGroup来说，除了完成自己的测量，还需要完成子元素的测量。ViewGroup是一个抽象类，为了测量子类，它提供了一个measureChildren方法：
//ViewGroup.class
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);
}
}
}
protected void measureChild(View child, int parentWidthMeasureSpec,
int parentHeightMeasureSpec) {
final LayoutParams lp = child.getLayoutParams();
//用子元素的LayoutParams构建MeasureSpec
final int childWidthMeasureSpec = getChildMeasureSpec(parentWidthMeasureSpec,
mPaddingLeft + mPaddingRight, lp.width);
final int childHeightMeasureSpec = getChildMeasureSpec(parentHeightMeasureSpec,
mPaddingTop + mPaddingBottom, lp.height);
child.measure(childWidthMeasureSpec, childHeightMeasureSpec);
}
可以看出ViewGroup的measureChildren方法最终会循环调用子元素的measure方法完成子元素的测量。
ViewGroup并没有定义自己的测量过程，因为它的测量过程要由子类自己完成，比如LinearLayout和RelativeLayout，显然测量过程是不同的。有兴趣的可以看看LinearLayout的onMearsure方法。
常见的在Activity中获取View的宽高的方法
View的measure过程和Activity生命周期方法是不同步的，需要用特殊的方法才能准确获取View的宽高
（1）onWindowFocusChanged方法中获取
@Override
public void onWindowFocusChanged(boolean hasFocus) {
super.onWindowFocusChanged(hasFocus);
if (hasFocus) {
int width = myView.getMeasuredWidth();
int height = myView.getMeasuredHeight();
}
}
需要注意的是onWindowFocusChanged方法会被调用多次
（2）view.post(runnable)
通过view的post方法可以将一个runnable投递到消息队列的尾部，当Looper调用此runnable时，View已经初始化好了
myView.post(new Runnable() {
@Override
public void run() {
int width = myView.getMeasuredWidth();
int height = myView.getMeasuredHeight();
}
});
（3）ViewTreeObserver
利用ViewTreeObserver的OnGlobalLayoutListener回调接口，当View树发生状态改变时会回调这个接口
ViewTreeObserver viewTreeObserver = myView.getViewTreeObserver();
viewTreeObserver.addOnGlobalLayoutListener(new ViewTreeObserver.OnGlobalLayoutListener() {
@Override
public void onGlobalLayout() {
myView.getViewTreeObserver().removeOnGlobalLayoutListener(this);
int width = myView.getMeasuredWidth();
int height = myView.getMeasuredHeight();
}
});
View的layout(布局)
layout的作用就是ViewGroup用来确定子元素的位置，ViewGroup的位置被确定后，就会调用onLayout方法，遍历所有的子元素并调用其layout方法，在layout方法中又会调用onLayout方法。layout方法确定View本身的位置，而onLayout方法用来确定子元素的位置。
//View.class
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;
//确定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);
...
}
...
}
protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
}
layout方法主要就做了2件事，一个是调用setFrame方法确定自身的位置，另一个就是调用onLayout方法确定子元素的位置。
我们看到在View中并没有实现onLayout方法，同样的在ViewGroup中也没有实现onLayout方法，这是因为onLayout的具体实现同样和具体的布局有关，所以需要子类根据具体情况去实现。大家有兴趣可以看看LinearLayout的onLayout的实现。
需要注意的是默认情况下测量的宽高和最终的宽高是一样的，也就是getMeasuredWidth和getWidth是一样的。只不过一个获取的是measure过程后得到的宽高，一个是layout过程后的宽高。所以如果measure过程需要进行多次或是认为改变了layout方法，就有可能2者不相等。不过绝大多数都是一样的。
View的draw(绘制)
Draw说白了就是把View的内容绘制到屏幕上
@CallSuper
public void draw(Canvas canvas) {
...
/*
* 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
* 4. Draw children
* 5. If necessary, draw the fading edges and restore layers
* 6. Draw decorations (scrollbars for instance)
*/
// Step 1, draw the background, if needed
int saveCount;
//绘制背景
if (!dirtyOpaque) {
drawBackground(canvas);
}
...
if (!verticalEdges && !horizontalEdges) {
// Step 3, draw the content
//调用onDraw方法绘制内容
if (!dirtyOpaque) onDraw(canvas);
// Step 4, draw the children
//调用dispatchDraw方法绘制子元素
dispatchDraw(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);
// we're done...
return;
}
...
}
从上面的draw方法中，我们可以看出，绘制过程遵循如下几步：
（1）绘制背景：drawBackground(Canvas canvas)
（2）绘制自身内容：onDraw(canvas)
（3）绘制子元素：dispatchDraw(canvas)
（4） 绘制装饰：onDrawForeground(canvas)
View的三大流程开始的地方—ViewRootImpl
上面这张图是一张很经典的图，很好的描述了View的绘制流程。ViewRootImpl中的performTraversals方法会调用performMeasure、performLayout、performDraw方法，开始View的测量、布局和绘制过程。那ViewRootImpl中的performTraversals方法又是在什么时候被调用的呢？这就需要理解一个窗口的概念，也就是Window。
Android中的Window
Window是一个抽象的概念，每一个Window都对应着一个View和ViewRootImpl，Window通过ViewRootImpl来和View建立联系。Android中所有的视图都是通过都是通过Window来呈现的，不管是Activity、Dialog、还是Toast，它们的View都是附加在Window上的，因此Window实际上是View的直接管理者。比如我们触摸屏幕的事件，就是通过Window传递给DecorView，然后再由DecorView传递给我们的View。我们在Activity、Dialog中设置视图内容的方法setContentView在底层也是通过Window来完成的
Window的添加过程
我们在启动一个Activity或是一个Dialog时，系统都会为我们创建一个Window，并把创建的Window注册到系统的WindowManagerService中。
Window的添加过程需要通过WindowManager的实现类WindowManagerImpl的addView方法来实现。只有在通过addView方法将View添加到Window中后，我们的View才和Window关联起来，才能接收通过Window传递的各种输入信息
//WindowManagerImpl.class
private final WindowManagerGlobal mGlobal = WindowManagerGlobal.getInstance();
@Override
public void addView(@NonNull View view, @NonNull ViewGroup.LayoutParams params) {
applyDefaultToken(params);
mGlobal.addView(view, params, mContext.getDisplay(), mParentWindow);
}
由WindowManagerImpl的源码我们发现，WindowManagerImpl把添加View的工作都交给了WindowManagerGlobal类处理。我们来简单看看WindowManagerGlobal类
//WindowManagerGlobal.class
//所有Window所对应的View
private final ArrayList<View> mViews = new ArrayList<View>();
//所有Window对应的ViewRootImpl
private final ArrayList<ViewRootImpl> mRoots = new ArrayList<ViewRootImpl>();
//多有Window对应的布局参数
private final ArrayList<WindowManager.LayoutParams> mParams =
new ArrayList<WindowManager.LayoutParams>();
//正在被删除的View
private final ArraySet<View> mDyingViews = new ArraySet<View>();
public void addView(View view, ViewGroup.LayoutParams params,
Display display, Window parentWindow) {
...
//创建ViewRootImpl
root = new ViewRootImpl(view.getContext(), display);
view.setLayoutParams(wparams);
//将Window的一系列对象添加到对应的列表中
mViews.add(view);
mRoots.add(root);
mParams.add(wparams);
// do this last because it fires off messages to start doing things
try {
//调用ViewRootImpl的setView方法
root.setView(view, wparams, panelParentView);
} catch (RuntimeException e) {
// BadTokenException or InvalidDisplayException, clean up.
if (index >= 0) {
removeViewLocked(index, true);
}
throw e;
}
}
源码中已经做了相应的注释了。这里我们看到WindowManagerGlobal在addView方法中创建ViewRootImpl后，最后调用了ViewRootImpl的setView方法。下面我们来看看ViewRootImpl的setView方法
//ViewRootImpl.class
public void setView(View view, WindowManager.LayoutParams attrs, View panelParentView) {
synchronized (this) {
if (mView == null) {
...
//调用了requestLayout进行View的绘制
requestLayout();
...
try {
mOrigWindowType = mWindowAttributes.type;
mAttachInfo.mRecomputeGlobalAttributes = true;
collectViewAttributes();
//这里调用WindowSession的addToDisplay方法注册Window
res = mWindowSession.addToDisplay(mWindow, mSeq, mWindowAttributes,
getHostVisibility(), mDisplay.getDisplayId(),
mAttachInfo.mContentInsets, mAttachInfo.mStableInsets,
mAttachInfo.mOutsets, mInputChannel);
} catch (RemoteException e) {
mAdded = false;
mView = null;
mAttachInfo.mRootView = null;
mInputChannel = null;
mFallbackEventHandler.setView(null);
unscheduleTraversals();
setAccessibilityFocus(null, null);
throw new RuntimeException("Adding window failed", e);
} finally {
if (restore) {
attrs.restore();
}
}
...
}
}
}
@Override
public void requestLayout() {
if (!mHandlingLayoutInLayoutRequest) {
checkThread();
mLayoutRequested = true;
scheduleTraversals();
}
}
在ViewRootImpl的setView方法中主要是做了2件事，一个是调用requestLayout方法启动View的绘制流程；另一个是调用WindowSession的addToDisplay方法请求WindowManagerService添加Window，这是一次IPC调用。
至此，我们就分析完Window的添加过程了，总结如下：
（1）View的展示以及处理触摸点击事件离不开Window，2者通过ViewRootImpl进行关联
（2）我们在启动Activity、创建Dialog或是弹出Toast时都会创建一个Window，然后会通过WindowManagerGlobal类的addView方法来创建ViewRootImpl类，并将Window、View、ViewRootImpl关联起来，
（3）在创建完ViewRootImpl后，接着会调用ViewRootImpl的setView方法，在setView方法中通过requestLayout方法最终调用到performTraversals方法开启View的三大流程；通过WindowSession的addToDisplay方法向WindowManagerService发起远程IPC调用，完成Window的添加。
总结
（1）在通过继承View的方式自定义View时，需要特别处理wrap_content的情况，因为View中默认相当于没处理(和match_parent效果一样)
（2）在Activity中获取View的宽高需要用特殊的方式：onWindowFocusChanged、view.post(runnable)、ViewTreeObserver的OnGlobalLayoutListener
（3）我们的View的显示离不来Window，无论是Activity、Dialog还是Toast，都对应着一个Window。View和Window通过ViewRootImpl来建立关联。我们显示、更新、隐藏界面，比如Dialog的show和dismiss，说到底是Window中添加、更新和删除View的过程。
（4）我们通过setContentView方法添加View，其实是对应Window的添加View的过程，Window会创建ViewRootImpl来执行注册Window、开启View的绘制流程的操作。
（5）所以综上，我们显示一个界面的过程为：创建Window–>创建ViewRootImpl–>添加View–>绘制View、注册Window
相关文章
赣公网安备36020002000448号