再过几个月就要30了，给自己定了一个小目标, 三年后会是怎样呢......
1. 核心成员与标记
1. LEFT_OF, RIGHT_OF,ABOVE,BELOW: 声明某个子child相对于另外一个子child的位置。
2. ALIGN_BASELINE：某个child和另一个child的基准线对齐。
3. ALIGN_LEFT，ALIGN_TOP，ALIGN_RIGHT，ALIGN_BOTTOM：某个child和另外一个child的对齐方式，左对齐，右对齐，上对齐，下对齐。
4. ALIGN_PARENT_LEFT，ALIGN_PARENT_TOP，ALIGN_PARENT_RIGHT，ALIGN_PARENT_BOTTOM：某个child和RelativeLayout的父容器的对齐方式。左，右，上，下对齐。
5. CENTER_IN_PARENT：child位于parent的正中间布局。
6. CENTER_HORIZONTAL：child位于parent的水平中间布局。
7. CENTER_VERTICAL：child位于parent的垂直中间布局。
8. START_OF，END_OF，ALIGN_START，ALIGN_END， ALIGN_PARENT_START，ALIGN_PARENT_END：相对于上面的left/end, align_left/align_right等考虑了相对方向，也就是从右到左的布局。
9. RULES_VERTICAL：包含了ABOVE, BELOW, ALIGN_BASELINE, ALIGN_TOP, ALIGN_BOTTOM，他的意思是子child之间互相依赖来定位的标记。特指纵向哦。
10. RULES_HORIZONTAL：包含了LEFT_OF, RIGHT_OF, ALIGN_LEFT, ALIGN_RIGHT, START_OF, END_OF, ALIGN_START, ALIGN_END，他的意思是子child之间需互相依赖来定位的标记，特指横向哦。
11. gravity属性：可以指定子view为left,top, right, bottom等位置摆放。
2. 内部类
-
RelativeLayout.LayoutParams
这是一个给RelativeLayout的子child提供的布局参数。
- mRules: 在LayoutParams的构造函数中记录了left, right, align, start等各种标记过的view元素的id.
- resolveRules(): 将设定的start, end等布局方向相关的属性转换成对应的lef, right。注意的是如果start和left同时设定了，那么优先考虑start.end如right同理。这里还考虑到targetversion是低于17, 那么start, end等类似的属性是无效的，将他们直接转换成left, right.施加的布局方向是没有作用的呢。
- resolveLayoutDirection：给LayoutParams设定布局方向，同时他还会调用上面的resolveRules重新解析Relativelayout的布局策略。
-
RelativeLayout.DependencyGraph
主要目的是为RelativeLayout确定view的定位布局的顺序，即先布局哪个，后布局哪个元素。将这些确定顺序的view放置到一个容器中，这里面有依赖的关系线。
mNodes：记录了所有的view。
mKeyNodes: 和上面的一样记录了所有的view, 但是以key-value的方式，key为view的id。
mRoots： 本意是记录一些不需要依赖其他view的位置来定位自己的view. 经过内部处理后和依赖关系的移除之后，里面就是mNodes中所有的view了。
-
DependencyGraph.findRoots方法
该方法的意图是根据纵向或者横向的依赖标记来找出不依赖其他child定位的child
private ArrayDequefindRoots(int[] rulesFilter) { final SparseArray keyNodes = mKeyNodes; final ArrayList nodes = mNodes; final int count = nodes.size(); // Find roots can be invoked several times, so make sure to clear // all dependents and dependencies before running the algorithm for (int i = 0; i < count; i++) { final Node node = nodes.get(i); node.dependents.clear(); node.dependencies.clear(); } // Builds up the dependents and dependencies for each node of the graph for (int i = 0; i < count; i++) { final Node node = nodes.get(i); final LayoutParams layoutParams = (LayoutParams) node.view.getLayoutParams(); final int[] rules = layoutParams.mRules; final int rulesCount = rulesFilter.length; //1.这里是关键的地方，根据rulesFilter选择的标记，来找到当前view依赖的child-view。找到了依赖之后。把当前view添加到他的附属集合里面去，把依赖view添加到当前view的附主集合里面去。 for (int j = 0; j < rulesCount; j++) { final int rule = rules[rulesFilter[j]]; if (rule > 0) { // The node this node depends on final Node dependency = keyNodes.get(rule); // Skip unknowns and self dependencies if (dependency == null || dependency == node) { continue; } // Add the current node as a dependent dependency.dependents.put(node, this); // Add a dependency to the current node node.dependencies.put(rule, dependency); } } } final ArrayDeque roots = mRoots; roots.clear(); //遍历所有的view, 把那些没有附主依赖项的添加到root集合。也就是说这些view可以是根view一样，可以首先定位。 // Finds all the roots in the graph: all nodes with no dependencies for (int i = 0; i < count; i++) { final Node node = nodes.get(i); if (node.dependencies.size() == 0) roots.addLast(node); } return roots; }
-
DependencyGraph.getSortedViews方法
填充mRoots集合，他会将那些依赖其他兄弟view定位的view的陆续填入进去，它会先将被依赖的view放入到root中表示被依赖方已经稳定定位, 然后放入自己，确定这样的定位顺序。如果知道拓扑排序的话，就很容易理解这个过程啦, 拓扑排序就是按照依赖关系去排序，让排在前面的内容不会依赖排在后面的内容，这和我们的mRoot之中的依赖图谱是一致的哦.
void getSortedViews(View[] sorted, int... rules) { //找到第一批不需要依赖其他child定位的view集合。 final ArrayDequeroots = findRoots(rules); int index = 0; Node node; // 遍历root. while ((node = roots.pollLast()) != null) { final View view = node.view; final int key = view.getId(); //root的节点直接添加进去，他们是无依赖的。 sorted[index++] = view; //获取当前节点的附属项，假如B,C依赖A定位。那么A的的dependents就是B,C final ArrayMap dependencies = dependent.dependencies; //移除A附主方，因为A已经sort排好序了，这样B/C就可以说依赖的项就已知了。 dependencies.remove(key); //如果这里的附主方清0了，那么就可以作为root节点添加到root里面了。 //比如B除了依赖A, 可能还依赖D,那么要等下一次定位D之后才能将A-add进去哦。 if (dependencies.size() == 0) { roots.add(dependent); } } } graph.getSortedViews(mSortedVerticalChildren, RULES_VERTICAL); graph.getSortedViews(mSortedHorizontalChildren, RULES_HORIZONTAL); - 这两行代码意图是将所有的子child从横纵两个方向来计算view的定位顺序，也即mSortedHorizontalChildren, mSortedVerticalChildren。他里面的元素是按照定位顺序来排列的。
- Node
- dependents: 附属内容，如果b依赖a定位, 那么b是a的附属。a里面的dependents就是b这类元素。
- dependencies： 附主内容，如果b依赖a定位，那么a是b的附主。这个属性集合里面就是b所有依赖的附主方。
- View: 就是当前的节点的view。
3. 核心方法分解
onLayout: 因为RelativeLayout都是子child相对性地布局，所以只要计算出子child的坐标, 就可以知道child放置在什么位置。
sortChildren：生成两个集合，分别是纵行和横向的view集。他们都是RelativeLayout的子child全集，按照定位的顺序，排列成一个集合。后面的测量就从中取出一个个地测量啦。
-
onMeasue
RelativeLayout的核心算法，它分横向，纵行两个方向来测量RelativeLayout和子view, 这也是为什么说relativeLayout相对比较LinearLayout耗费性能, 它的逻辑概括起来分为四步：
- 横向的测量：定位，测量，计算最终位置;
- 纵向的测量: 定位，测量，计算最终位置;
- isWrapContentHeight， 修正高度
- isWrapContentWidth，修正宽度
注意：MeasureSpec.UNSPECIFIED，这个是测量模式在系统中使用构建的时候，一般和0一起组合使用，他表明当前view的测量规格是未知的。父容器没有给我明确的限制所以是UNSPECIFIED，我自己也不知道自己该多大所以是0，具体我的大小到我的具体实现中再去计算吧。这在relativelayout横竖测量的时候，对测量另外一个相对的数值有作用。
if (params.width == LayoutParams.MATCH_PARENT) { //这里解释了为什么当RelativeLayout是wrap的时候，子child是match的时候，得到的高度是精确模式，且尺寸为父容器最大。 childHeightMeasureSpec = MeasureSpec.makeMeasureSpec(maxHeight, MeasureSpec.EXACTLY); } else { childHeightMeasureSpec = MeasureSpec.makeMeasureSpec(maxHeight, MeasureSpec.AT_MOST); }-
onMeasue方法主体
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) { if (mDirtyHierarchy) { mDirtyHierarchy = false; //计算纵横两个集合。 sortChildren(); } ...... //横向测量 View[] views = mSortedHorizontalChildren; int count = views.length; for (int i = 0; i < count; i++) { View child = views[i]; if (child.getVisibility() != GONE) { LayoutParams params = (LayoutParams) child.getLayoutParams(); int[] rules = params.getRules(layoutDirection); applyHorizontalSizeRules(params, myWidth, rules); measureChildHorizontal(child, params, myWidth, myHeight); if (positionChildHorizontal(child, params, myWidth, isWrapContentWidth)) { offsetHorizontalAxis = true; } } } //纵向测量 views = mSortedVerticalChildren; count = views.length; final int targetSdkVersion = getContext().getApplicationInfo().targetSdkVersion; for (int i = 0; i < count; i++) { View child = views[i]; if (child.getVisibility() != GONE) { LayoutParams params = (LayoutParams) child.getLayoutParams(); //应用规则，找到child的top或者bottom位置。 applyVerticalSizeRules(params, myHeight); //测量child的宽与高。 measureChild(child, params, myWidth, myHeight); if (positionChildVertical(child, params, myHeight, isWrapContentHeight)) { offsetVerticalAxis = true; } //如果是wrap的宽，计算出RelativeLayout的最大宽度1。 if (isWrapContentWidth) { if (isLayoutRtl()) { if (targetSdkVersion < Build.VERSION_CODES.KITKAT) { width = Math.max(width, myWidth - params.mLeft); } else { width = Math.max(width, myWidth - params.mLeft - params.leftMargin); } } else { if (targetSdkVersion < Build.VERSION_CODES.KITKAT) { width = Math.max(width, params.mRight); } else { width = Math.max(width, params.mRight + params.rightMargin); } } } //如果是wrap的高，计算出RelativeLayout的最大高度1。 if (isWrapContentHeight) { if (targetSdkVersion < Build.VERSION_CODES.KITKAT) { height = Math.max(height, params.mBottom); } else { height = Math.max(height, params.mBottom + params.bottomMargin); } } if (child != ignore || verticalGravity) { left = Math.min(left, params.mLeft - params.leftMargin); top = Math.min(top, params.mTop - params.topMargin); } if (child != ignore || horizontalGravity) { right = Math.max(right, params.mRight + params.rightMargin); bottom = Math.max(bottom, params.mBottom + params.bottomMargin); } } } ....... //wrap的宽，矫正前面positionChildHorizontal返回true的child的left,right属性。 if (isWrapContentWidth) { // Width already has left padding in it since it was calculated by looking at // the right of each child view width += mPaddingRight; if (mLayoutParams != null && mLayoutParams.width >= 0) { width = Math.max(width, mLayoutParams.width); } width = Math.max(width, getSuggestedMinimumWidth()); width = resolveSize(width, widthMeasureSpec); if (offsetHorizontalAxis) { for (int i = 0; i < count; i++) { View child = getChildAt(i); if (child.getVisibility() != GONE) { LayoutParams params = (LayoutParams) child.getLayoutParams(); final int[] rules = params.getRules(layoutDirection); if (rules[CENTER_IN_PARENT] != 0 || rules[CENTER_HORIZONTAL] != 0) { centerHorizontal(child, params, width); } else if (rules[ALIGN_PARENT_RIGHT] != 0) { final int childWidth = child.getMeasuredWidth(); params.mLeft = width - mPaddingRight - childWidth; params.mRight = params.mLeft + childWidth; } } } } } //wrap的高，矫正前面positionChildVertical返回true的child的top,bottom属性。 if (isWrapContentHeight) { // Height already has top padding in it since it was calculated by looking at // the bottom of each child view height += mPaddingBottom; if (mLayoutParams != null && mLayoutParams.height >= 0) { height = Math.max(height, mLayoutParams.height); } height = Math.max(height, getSuggestedMinimumHeight()); height = resolveSize(height, heightMeasureSpec); if (offsetVerticalAxis) { for (int i = 0; i < count; i++) { View child = getChildAt(i); if (child.getVisibility() != GONE) { LayoutParams params = (LayoutParams) child.getLayoutParams(); final int[] rules = params.getRules(layoutDirection); if (rules[CENTER_IN_PARENT] != 0 || rules[CENTER_VERTICAL] != 0) { centerVertical(child, params, height); } else if (rules[ALIGN_PARENT_BOTTOM] != 0) { final int childHeight = child.getMeasuredHeight(); params.mTop = height - mPaddingBottom - childHeight; params.mBottom = params.mTop + childHeight; } } } } } //默认这个都是false,但是如果relativelayout设置了Gravity.END, Gravity.Bottom, //那么就会将内容右边或者底部顶边，这时候就需要矫正child的left, child的right, top, bottom属性呢。因为前面的left, right，top, bottom属性都是从start, top这个顶边位置开始计算的。 if (horizontalGravity || verticalGravity) { final Rect selfBounds = mSelfBounds; selfBounds.set(mPaddingLeft, mPaddingTop, width - mPaddingRight, height - mPaddingBottom); final Rect contentBounds = mContentBounds; Gravity.apply(mGravity, right - left, bottom - top, selfBounds, contentBounds, layoutDirection); final int horizontalOffset = contentBounds.left - left; final int verticalOffset = contentBounds.top - top; if (horizontalOffset != 0 || verticalOffset != 0) { for (int i = 0; i < count; i++) { View child = getChildAt(i); if (child.getVisibility() != GONE && child != ignore) { LayoutParams params = (LayoutParams) child.getLayoutParams(); if (horizontalGravity) { params.mLeft += horizontalOffset; params.mRight += horizontalOffset; } if (verticalGravity) { params.mTop += verticalOffset; params.mBottom += verticalOffset; } } } } } if (isLayoutRtl()) { final int offsetWidth = myWidth - width; for (int i = 0; i < count; i++) { View child = getChildAt(i); if (child.getVisibility() != GONE) { LayoutParams params = (LayoutParams) child.getLayoutParams(); params.mLeft -= offsetWidth; params.mRight -= offsetWidth; } } } //设定RelativeLayout的最终的宽与高。 setMeasuredDimension(width, height); }
getChildMeasureSpec： 这个和viewGroup中的同名方法的实现不一样哦，google工程师这里重新实现了一套逻辑。但是感觉这些逻辑有些乱啊，简单总结下他的基本逻辑。
如果childStart， childEnd都设定了，childSpecMode=EXACTLY, childSpecSize=childEnd-childStart
否则，childSize>0, childSpecMode=EXACTLY, childSpecSize是maxAvailable和childSize中最小的一个。
-
否则，childSize == LayoutParams.MATCH_PARENT：
childSpecMode = MeasureSpec.EXACTLY; childSpecSize = maxAvailable; - 这里也可以看出不关心父容器本身的模式，只要我是MATCH_PARENT,结果就是EXACTLY，这个和viewGroup的计算是大不同的哦。 -
childSize == LayoutParams.WRAP_CONTENT：
childSpecMode = MeasureSpec.AT_MOST; childSpecSize = maxAvailable; -
applyHorizontalSizeRules：计算child的left或者right位置。
- 找到它依赖定位的view,然后根据rulues规则计算出他的left, 或right的数值。 - 当规则是ALIGN_PARENT_RIGHT时候，计算出的childParams.mRight是根据myWidth来的，这个时候的myWidth并不一定是确定的，如果是RelativeLayout是Wrap_conent,那么在后面确定了width之后要重新再计算一次childParams.mRight。 -
measureChildHorizontal： 测量child的宽度，高度也测量但不是最终的结果。
- 根据params.mLeft,params.mRight或者childWith来计算出child的宽度测量规格childWidthMeasureSpec - 根据myHeight来和params.width的模式得出高度的测量规格childHeightMeasureSpec 注意：这时候的childHeightMeasureSpec时候不准确的，只是为了方便测宽度，大概出的一个值。 - 测量child.
-
positionChildHorizontal：根据left/right以及前面测量的宽度来计算child的位置。
- 因为之前经过了宽度的测量，那么宽度是已知的了，然后通过这个宽度来得出child的left, right的位置。方便后续的layout. - 如果是CENTER_IN_PARENT，CENTER_HORIZONTAL，ALIGN_PARENT_END的三种该方法返回true.表示left,right的位置计算依赖了不确定的父容器，所以等到父容器确定之后需要再定一次left,right.
-
applyVerticalSizeRules：计算child的top或者bottom位置。
- 和measureChildHorizontal同理，计算出纵向的top, bottom -
measureChild： 测量child的最终的宽与高。
- 得出宽度的计算规格是childWidthMeasureSpec, 宽度其实前面已经计算好了。 - 得出高度的计算规格, 高度是childHeightMeasureSpec，经过前面的定位辅助，以及考虑child的height. - child.measure(childWidthMeasureSpec, childHeightMeasureSpec);最终的测量宽与高。 positionChildVertical：根据left/right以及前面测量的宽度来计算child的位置。
-
有了前面的宽，高，然后就可以定位child, 可以获取到他的top,bottom属性。
- 如果是CENTER_IN_PARENT，CENTER_HORIZONTAL，ALIGN_PARENT_END的三种该方法返回true.表示left,right的位置计算依赖了不确定的父容器，所以等到父容器确定之后需要再定一次top,bottom.
4. 总结
- RelativeLayout的重点在测量处，缺点也是在这里。对于子控件都要横竖测量两遍，这是一个较为耗费性能的地方，所以平时如果可以尽量不要用这个控件哦, 用LinearLayout取代啦。