android视图构成

image.png

Activity的window组成，Activity内部有个Window成员，它的实例为PhoneWindow，PhoneWindow有个内部类是DecorView，这个DecorView就是存放布局文件的，里面有TitleActionBar和我们setContentView传入进去的layout布局文件

Window类时一个抽象类，提供绘制窗口的API
PhoneWindow是继承Window的一个具体的类，该类内部包含了一个DecorView对象，该DectorView对象是所有应用窗口(Activity界面)的根View
DecorView继承FrameLayout，DecorView作为顶级View，一般情况下它内部会包含一个竖直方向的LinearLayout，在这个LinearLayout里面有上下两个部分(具体情况和Android的版本及主题有关)，上面是【标题栏】，下面是【内容栏】。在Activity中我们通过setContentView所设置的布局文件其实就是被加载到【内容栏】中的，而内容栏的id是content，因此指定布局的方法叫setContent()。

依据面向对象从抽象到具体我们可以类比上面关系就像如下：
Window是一块电子屏，PhoneWindow是一块手机电子屏，DecorView就是电子屏要显示的内容，Activity就是手机电子屏安装位置

setContentView流程

setContentView整个过程主要是如何把Activity的布局文件或者java的View添加至窗口里，重点概括为：

创建一个DecorView的对象mDecor，该mDecor对象将作为整个应用窗口的根视图。

依据Feature等style theme创建不同的窗口修饰布局文件，并且通过findViewById获取Activity布局文件该存放的地方（窗口修饰布局文件中id为content的FrameLayout）。

将Activity的布局文件添加至id为content的FrameLayout内。

当setContentView设置显示OK以后会回调Activity的onContentChanged方法。Activity的各种View的findViewById()方法等都可以放到该方法中，系统会帮忙回调。

ViewRoot的概念

ViewRoot对应于ViewRootImpl类，它是连接WindowManager和DecorView的纽带，View的三大流程均是通过ViewRoot来完成的。在ActivityThread中，当Activity对象被创建完之后，会讲DecorView添加到Window中，同时会创建对应的ViewRootImpl，并将ViewRootImpl和DecorView建立关联，并保存到WindowManagerGlobal对象中。

View的绘制基本分为measure、layout、draw 过程.

measure 测量组件本身的大小
layout 确定组件在视图中的位置
draw 根据位置和大小，将组件画出来

视图绘制的起点在ViewRootImpl类的performTraversals()方法，该方法完成的工作主要是：根据之前的状态，判定是否重新计算测试视图大小（measure）、是否重新放置视图位置（layout）和是否重新重绘视图（draw）。

image.png

Measure测量

为了更好地理解View的测量过程，我们还需要理解MeasureSpec，它是View的一个内部类，它表示对View的测量规格。MeasureSpec代表一个32位int值，高2位代表SpecMode(测量模式)，低30位代表SpecSize(测量大小)，我们可以看看它的具体实现：

MeasureSpec.java
 
public static class MeasureSpec { 
 private static final int MODE_SHIFT = 30;
 private static final int MODE_MASK = 0x3 << MODE_SHIFT;
 
 /**
  * UNSPECIFIED 模式：
  * 父View不对子View有任何限制，子View需要多大就多大
  */
 public static final int UNSPECIFIED = 0 << MODE_SHIFT;
 
 /**
  * EXACTYLY 模式：
  * 父View已经测量出子Viwe所需要的精确大小，这时候View的最终大小
  * 就是SpecSize所指定的值。对应于match_parent和精确数值这两种模式
  */
 public static final int EXACTLY = 1 << MODE_SHIFT;
 
 /**
  * AT_MOST 模式：
  * 子View的最终大小是父View指定的SpecSize值，并且子View的大小不能大于这个值，
  * 即对应wrap_content这种模式
  */
 public static final int AT_MOST = 2 << MODE_SHIFT;
 
 //将size和mode打包成一个32位的int型数值
 //高2位表示SpecMode，测量模式，低30位表示SpecSize，某种测量模式下的规格大小
 public static int makeMeasureSpec(int size, int mode) {
  if (sUseBrokenMakeMeasureSpec) {
  return size + mode;
  } else {
  return (size & ~MODE_MASK) | (mode & MODE_MASK);
  }
 }
 
 //将32位的MeasureSpec解包，返回SpecMode,测量模式
 public static int getMode(int measureSpec) {
  return (measureSpec & MODE_MASK);
 }
 
 //将32位的MeasureSpec解包，返回SpecSize，某种测量模式下的规格大小
 public static int getSize(int measureSpec) {
  return (measureSpec & ~MODE_MASK);
 }
 //...
 }

MeasureSpec通过将SpecMode和SpecSize打包成一个int值来避免过多的对象内存分配，并提供了打包和解包的方法。
SpecMode有三种类型,每一类都表示特殊的含义：

UNSPECIFIED
父容器不对View有任何限制，要多大就给多大，这种情况一般用于系统内部，表示一种测量的状态；
EXACTLY
父容器已经检测出View所需的精确大小，这个时候View的最终打消就是SpecSize所指定的值。它对应于LayoutParams中的match_parent和具体数值这两种模式。
AT_MOST
父容器指定了一个可用大小即SpecSize，View的大小不能大于这个值，具体是什么值要看不同View的具体实现。它对应于LayoutParams中wrap_content。
View的MeasureSpec是由父容器的MeasureSpec和自己的LayoutParams决定的，但是对于DecorView来说有点不同，因为它没有父类。在ViewRootImpl中的measureHierarchy方法中有如下一段代码展示了DecorView的MeasureSpec的创建过程，其中desiredWindowWidth和desireWindowHeight是屏幕的尺寸大小：

ViewGroup的measure

childWidthMeasureSpec = getRootMeasureSpec(desiredWindowWidth, lp.width);`

childHeightMeasureSpec = getRootMeasureSpec(desiredWindowHeight, lp.height);`

performMeasure(childWidthMeasureSpec, childHeightMeasureSpec);

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

通过以上代码，DecorView的MeasureSpec的产生过程就很明确了，因为DecorView是FrameLyaout的子类，属于ViewGroup，对于ViewGroup来说，除了完成自己的measure过程外，还会遍历去调用所有子元素的measure方法，各个子元素再递归去执行这个过程。和View不同的是，ViewGroup是一个抽象类，他没有重写View的onMeasure方法，这里很好理解，因为每个具体的ViewGroup实现类的功能是不同的，如何测量应该让它自己决定，比如LinearLayout和RelativeLayout。
因此在具体的ViewGroup中需要遍历去测量子View，这里我们看看ViewGroup中提供的测量子View的measureChildWithMargins方法：

protected void measureChildWithMargins(View child,
 int parentWidthMeasureSpec, int widthUsed,
 int parentHeightMeasureSpec, int heightUsed) {
final MarginLayoutParams lp = (MarginLayoutParams) child.getLayoutParams();
 
final int childWidthMeasureSpec = getChildMeasureSpec(parentWidthMeasureSpec,
 mPaddingLeft + mPaddingRight + lp.leftMargin + lp.rightMargin
  + widthUsed, lp.width);
final int childHeightMeasureSpec = getChildMeasureSpec(parentHeightMeasureSpec,
 mPaddingTop + mPaddingBottom + lp.topMargin + lp.bottomMargin
  + heightUsed, lp.height);
 
child.measure(childWidthMeasureSpec, childHeightMeasureSpec);
}

上述方法会对子元素进行measure，在调用子元素的measure方法之前会先通过getChildMeasureSpec方法来得到子元素的MeasureSpec。从代码上看，子元素的MeasureSpec的创建与父容器的MeasureSpec和本身的LayoutParams有关，此外和View的margin和父类的padding有关，现在看看getChildMeasureSpec的具体实现：

ViewGroup.java
 
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;
 
 // Parent asked to see how big we want to be
 case MeasureSpec.UNSPECIFIED:
 if (childDimension >= 0) {
  // Child wants a specific size... let him have it
  resultSize = childDimension;
  resultMode = MeasureSpec.EXACTLY;
 } else if (childDimension == LayoutParams.MATCH_PARENT) {
  // Child wants to be our size... find out how big it should
  // be
  resultSize = View.sUseZeroUnspecifiedMeasureSpec ? 0 : size;
  resultMode = MeasureSpec.UNSPECIFIED;
 } else if (childDimension == LayoutParams.WRAP_CONTENT) {
  // Child wants to determine its own size.... find out how
  // big it should be
  resultSize = View.sUseZeroUnspecifiedMeasureSpec ? 0 : size;
  resultMode = MeasureSpec.UNSPECIFIED;
 }
 break;
 }
 //noinspection ResourceType
 return MeasureSpec.makeMeasureSpec(resultSize, resultMode);
}

上述代码根据父类的MeasureSpec和自身的LayoutParams创建子元素的MeasureSpec，具体过程同学们自行分析，最终的创建规则如下表：

image.png

ViewGroup在遍历完子View后，需要根据子元素的测量结果来决定自己最终的测量大小，并调用setMeasuredDimension方法保存测量宽高值。

solveSizeAndState(maxWidth, widthMeasureSpec, childState),heightSizeAndState);

这里调用了resolveSizeAndState来确定最终的大小，主要是保证测量的大小不能超过父容器的最大剩余空间maxWidth，这里我们看看它里面的实现：

public static int resolveSizeAndState(int size, int measureSpec, int childMeasuredState) {
final int specMode = MeasureSpec.getMode(measureSpec);
final int specSize = MeasureSpec.getSize(measureSpec);
final int result;
switch (specMode) {
 case MeasureSpec.AT_MOST:
 if (specSize < size) {
  result = specSize | MEASURED_STATE_TOO_SMALL;
 } else {
  result = size;
 }
 break;
 case MeasureSpec.EXACTLY:
 result = specSize;
 break;
 case MeasureSpec.UNSPECIFIED:
 default:
 result = size;
}
return result | (childMeasuredState & MEASURED_STATE_MASK);
}

onMeasure里面的步骤总结：

根据各自的测量规则遍历Children元素，调用getChildMeasureSpec方法得到Child的measureSpec;
调用Child的measure方法;
调用setMeasuredDimension确定最终的大小。

View的measure

View的measure过程由其measure方法来完成，measure方法是一个final类型的方法，这意味着子类不能重写此方法，在View的measure方法里面会去调用onMeasure方法，我们这里只要看onMeasure的实现即可，如下：

View.java

protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
 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;
 }

View的宽/高由specSize决定，直接继承View的自定义控件需要重写onMeasure方法并设置wrap_content时的自身大小，否则在布局中使用wrap_content就相当于使用match_parent。

上述就是View的measure大致过程，在measure完成之后，通过getMeasuredWidth/Height方法就可以获得测量后的宽高，这个宽高一般情况下就等于View的最终宽高了，因为View的layout布局的时候就是根据measureWidth/Height来设置宽高的，除非在layout中修改了measure值。

Layout布局

Layout的作用是ViewGroup用来确定子元素的位置，当ViewGroup的位置被确定后，它在onLayout中会遍历所有的子元素并调用其layout方法。简单的来说就是，layout方法确定View本身的位置，而onLayout方法则会确定所有子元素的位置。
先看看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 listenersCopy =
     (ArrayList)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);
   }
  }
 }
 
 mPrivateFlags &= ~PFLAG_FORCE_LAYOUT;
 mPrivateFlags3 |= PFLAG3_IS_LAID_OUT;
}

主要看到这里：

boolean changed = isLayoutModeOptical(mParent) ?setOpticalFrame(l, t, r, b) : setFrame(l, t, r, b);

isLayoutModeOptical方法判断是否显示边界布局(这个东西不知道是啥，暂时不理会)，setOpticalFrame方法内部最终也是调用setFrame方法，这里我们看setFrame方法就可以了：

protected boolean setFrame(int left, int top, int right, int bottom) {
 boolean changed = false;
 
 if (DBG) {
  Log.d("View", this + " View.setFrame(" + left + "," + top + ","
 + right + "," + bottom + ")");
 }
 //1、如果有一个值发生了改变，那么就需要重新调用onLayout方法了，后面会分析到
 if (mLeft != left || mRight != right || mTop != top || mBottom != bottom) {
  changed = true;
 
  // Remember our drawn bit
  int drawn = mPrivateFlags & PFLAG_DRAWN;
 
  //2、保存旧的宽和高
  int oldWidth = mRight - mLeft;
  int oldHeight = mBottom - mTop;
  //计算新的宽和高
  int newWidth = right - left;
  int newHeight = bottom - top;
  //3、判断宽高是否有分生变化
  boolean sizeChanged = (newWidth != oldWidth) || (newHeight != oldHeight);
 
  //Invalidate our old position
  //4、如果大小变化了，在已绘制了的情况下就请求重新绘制
  invalidate(sizeChanged);
 
  //5、存储新的值
  mLeft = left;
  mTop = top;
  mRight = right;
  mBottom = bottom;
  mRenderNode.setLeftTopRightBottom(mLeft, mTop, mRight, mBottom);
 
  mPrivateFlags |= PFLAG_HAS_BOUNDS;
 
  if (sizeChanged) {
  //6、大小变化时进行处理
  sizeChange(newWidth, newHeight, oldWidth, oldHeight);
  }
 
  if ((mViewFlags & VISIBILITY_MASK) == VISIBLE || mGhostView != null) {
  //7、如果此时View是可见状态下，立即执行绘制操作
  invalidate(sizeChanged);
 
  }
 
  mPrivateFlags |= drawn;
 
  mBackgroundSizeChanged = true;
  if (mForegroundInfo != null) {
  mForegroundInfo.mBoundsChanged = true;
  }
 
  notifySubtreeAccessibilityStateChangedIfNeeded();
 }
 return changed;
}

首先判断四个顶点的位置是否有变化；
判断宽高是否有变化，如果变化了则请求重新绘制；
保存新的值TOP、LEFT、BOTTOM、RIGHT。
可以看到changed的值只与四个点是否发生了变化有关。同时，我们还发现，在setframe方法后，就可以获得某个view的top、left、right、bottom的值了。
回到layout方法中，继续执行会调用onLayout方法，我们看看其代码：

protected void onLayout(boolean changed, int left, int top, int right, int bottom) {}

可以看到这是一个空实现，和onMeasure方法类似，onLayout的实现和具体的布局有关，具体ViewGroup的子类需要重写onLayout方法，并根据具体布局规则遍历调用Children的layout方法。

通过上面的分析，可以得到两个结论：

View通过layout方法来确认自己在父容器中的位置
ViewGroup通过onLayout 方法来确定View在容器中的位置
接下来我们看看FrameLayout的onLayout方法是怎么实现的：

@Override
protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
 layoutChildren(left, top, right, bottom, false /* no force left gravity */);
}
 
void layoutChildren(int left, int top, int right, int bottom, boolean forceLeftGravity) {
 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) {
   final LayoutParams lp = (LayoutParams) child.getLayoutParams();
 
   final int width = child.getMeasuredWidth();
   final int height = child.getMeasuredHeight();
 
   int childLeft;
   int childTop;
 
   int gravity = lp.gravity;
   if (gravity == -1) {
    gravity = DEFAULT_CHILD_GRAVITY;
   }
 
   final int layoutDirection = getLayoutDirection();
   final int absoluteGravity = Gravity.getAbsoluteGravity(gravity, layoutDirection);
   final int verticalGravity = gravity & Gravity.VERTICAL_GRAVITY_MASK;
 
   switch (absoluteGravity & Gravity.HORIZONTAL_GRAVITY_MASK) {
    case Gravity.CENTER_HORIZONTAL:
     childLeft = parentLeft + (parentRight - parentLeft - width) / 2 +
     lp.leftMargin - lp.rightMargin;
     break;
    case Gravity.RIGHT:
     if (!forceLeftGravity) {
      childLeft = parentRight - width - lp.rightMargin;
      break;
     }
    case Gravity.LEFT:
    default:
     childLeft = parentLeft + lp.leftMargin;
   }
 
   switch (verticalGravity) {
    case Gravity.TOP:
     childTop = parentTop + lp.topMargin;
     break;
    case Gravity.CENTER_VERTICAL:
     childTop = parentTop + (parentBottom - parentTop - height) / 2 +
     lp.topMargin - lp.bottomMargin;
     break;
    case Gravity.BOTTOM:
     childTop = parentBottom - height - lp.bottomMargin;
     break;
    default:
     childTop = parentTop + lp.topMargin;
   }
 
   child.layout(childLeft, childTop, childLeft + width, childTop + height);
  }
 }
}

1、获取父View的内边距padding的值
2、遍历子View，处理子View的layout_gravity属性、根据View测量后的宽和高、父View的padding值、来确定子View的布局参数，
3、调用child.layout方法，对子View进行布局

如果是自定义ViewGroup的话，需要重写onMeasure方法，在onMeasure方法里面遍历测量子元素，同理onLayout方法也是一样，最后实现onDraw方法绘制自己；
如果自定义View的话，则需要从写onMeasure方法，处理wrap_content的情况，不需要处理onLayout，最后实现onDraw方法绘制自己；

android view绘制机制和加载过程

android视图构成

setContentView流程

ViewRoot的概念

View的绘制基本分为measure、layout、draw 过程.

Measure测量

onMeasure里面的步骤总结：

View的measure

Layout布局

你可能感兴趣的:(android view绘制机制和加载过程)