RelativeLayout 原理浅析

最新推荐文章于 2023-06-30 10:56:22 发布

silenccce

最新推荐文章于 2023-06-30 10:56:22 发布

阅读量1k

点赞数 2

文章标签： Android RelativeLayout

本文链接：https://blog.csdn.net/hjf_huangjinfu/article/details/78573779

版权

转载请注明出处：http://blog.csdn.net/hjf_huangjinfu/article/details/78573779

概述

本文基于api level 26 的代码，简单描述一下 RelativeLayout 的内部工作原理。

1、先来看一个例子

下面我们会根据源代码和这个例子，来说明一下内部工作原理。
一个简单的布局文件：

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

    <TextView
        android:id="@+id/A"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:gravity="center"
        android:padding="10dp"
        android:text="A"/>

    <TextView
        android:id="@+id/B"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_above="@+id/D"
        android:layout_toRightOf="@id/A"
        android:gravity="center"
        android:padding="10dp"
        android:text="B"/>

    <TextView
        android:id="@+id/C"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_toRightOf="@id/B"
        android:gravity="center"
        android:padding="10dp"
        android:text="C"/>

    <TextView
        android:id="@id/D"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_alignParentBottom="true"
        android:layout_marginBottom="300dp"
        android:layout_toRightOf="@id/A"
        android:gravity="center"
        android:padding="10dp"
        android:text="D"/>

</RelativeLayout>

很简单，界面如下图所示：

这里有4个控件，暂且我们叫它们为A、B、C、D。
A没有任何依赖，放置在屏幕的左上角。
D依赖于A，放置在A的右边，D还依赖于parent，与parent对齐（为了方便显示，加了margin，不影响流程分析）。
B依赖于A、D，放置在A的右边，放置在D的上边。
C依赖于B，放置在B的右边。

2、约束规则

RelativeLayout 为它内部的每一个子View都生成一个约束规则（位置关系），约束规则有两大类：
相对规则，也就是说相对于它的兄弟View的约束规则取值为View的id（int型），比如：

android:layout_toRightOf="@id/A"

绝对规则，也就是相对于其父布局的约束规则，取值范围为【true / false】比如：

android:layout_alignParentBottom="true"

这些规则统一保存在View对象的RelativeLayout.LayoutParams 对象中，RelativeLayout.LayoutParams 对象使用一个int[] mRules 数组来存储约束规则，mRules数据逻辑是这样的，每一位对应一个约束规则，现在总共有22个约束规则，所以它的长度为22。
每一位的值，有三种情况：

-1：代表着绝对规则的true。

0：代表没有设置此条约束。
大于0的数:代表着相对规则的值，也就是所依赖View的Id。

各个索引位置代表的约束含义如下所示：

public static final int LEFT_OF                  = 0;
public static final int RIGHT_OF                 = 1;
public static final int ABOVE                    = 2;
public static final int BELOW                    = 3;
public static final int ALIGN_BASELINE           = 4;
public static final int ALIGN_LEFT               = 5;
public static final int ALIGN_TOP                = 6;
public static final int ALIGN_RIGHT              = 7;
public static final int ALIGN_BOTTOM             = 8;
public static final int ALIGN_PARENT_LEFT        = 9;
public static final int ALIGN_PARENT_TOP         = 10;
public static final int ALIGN_PARENT_RIGHT       = 11;
public static final int ALIGN_PARENT_BOTTOM      = 12;
public static final int CENTER_IN_PARENT         = 13;
public static final int CENTER_HORIZONTAL        = 14;
public static final int CENTER_VERTICAL          = 15;
public static final int START_OF                 = 16;
public static final int END_OF                   = 17;
public static final int ALIGN_START              = 18;
public static final int ALIGN_END                = 19;
public static final int ALIGN_PARENT_START       = 20;
public static final int ALIGN_PARENT_END         = 21;

除了约束规则，还有约束方向，也就是说是在哪个方向上面的约束，主要有水平方向和竖直方向。

上面的例子中，他们的约束关系是这样的：

A（Id = 2131165184）：

mRules全是0，mRules[0...21] = 0。

D（Id = 2131165189）：

mRules[1] = mRules[RIGHT_OF] = 2131165184。
mRules[12] = mRules[ALIGN_PARENT_BOTTOM] = -1。

其他位都是0。

B（Id = 2131165186）：

mRules[1] = mRules[RIGHT_OF] = 2131165184。

mRules[2] = mRules[ABOVE] = 2131165189。

其他位都是0。

C（Id = 2131165187）：

mRules[1] = mRules[RIGHT_OF] = 2131165186。

其他位都是0。

3、工作过程

RelativeLayout给内部的所有View，分别在水平和竖直两个方向上面，按照一定的规则进行排序（后面会说这个规则），排序后的View，存储在下面这两个数组中：

private View[] mSortedHorizontalChildren;
private View[] mSortedVerticalChildren;

RelativeLayout会分别在水平和竖直以相同的逻辑去处理这些View，这也就是为什么说在层级相同的情况下，能用LinearLayout就不用RelativeLayout，因为它要做两次处理，分别是水平和竖直方向，会影响性能。

排序规则，我们知道，ViewGroup在摆放子View的时候，是按照某种顺序一个一个摆放的，那么这就涉及到一个先后顺序的问题。又因为是RelativeLayout内部的子View有相互依赖的关系，所以第一步就需要找出所有的没有相对规则的View，因为这些View不依赖于其他兄弟View，所以可以很明确的知道他们的位置。

系统把这些没有相对依赖的View称为Roots，下面看一下代码：

/** 根据传进来的规则过滤器，来找到所有的没有相对规则的View
    规则过滤器，系统给了两大类，分别是 垂直过滤器 和 水平过滤器 ，过滤器中存储的是mRules值的索引。
    private static final int[] RULES_VERTICAL = {
            ABOVE, BELOW, ALIGN_BASELINE, ALIGN_TOP, ALIGN_BOTTOM
    };

    private static final int[] RULES_HORIZONTAL = {
            LEFT_OF, RIGHT_OF, ALIGN_LEFT, ALIGN_RIGHT, START_OF, END_OF, ALIGN_START, ALIGN_END
    };
    也就是说，在某一个方向上，当某一个View，它的约束规则（mRules），比如说垂直方向，RULES_VERTICAL 数组中的这些约束，在mRules中都为0，那么它就可以成为这个方向上的Root。
*/
private ArrayDeque<Node> findRoots(int[] rulesFilter) {
    final SparseArray<Node> keyNodes = mKeyNodes;
    final ArrayList<Node> nodes = mNodes;
    final int count = nodes.size();

    //清理掉所有的上次计算结果
    for (int i = 0; i < count; i++) {
        final Node node = nodes.get(i);
        node.dependents.clear();
        node.dependencies.clear();
    }

    // 为每一个View构建它的依赖和被依赖关系
    for (int i = 0; i < count; i++) {
	//需要分析的View（Node对View做了包裹）
        final Node node = nodes.get(i);
	//取出View的布局参数，主要就是拿到mRules。
        final LayoutParams layoutParams = (LayoutParams) node.view.getLayoutParams();
        final int[] rules = layoutParams.mRules;
        final int rulesCount = rulesFilter.length;

	//检测mRules中，指定的规则过滤器中的规则，有没有被设置了值。
        for (int j = 0; j < rulesCount; j++) {
            final int rule = rules[rulesFilter[j]];
		//rule大于0，说明是一个View的Id，说明这个约束规则依赖于另外一个Id为rule的View。就说明该View依赖于Id为rule的View，依赖规则为rulesFilter[j]。
            if (rule > 0) {
		//找到Id为rule的View，也就是被该View依赖的View
                final Node dependency = keyNodes.get(rule);
                // 跳过未知依赖和自我依赖
                if (dependency == null || dependency == node) {
                    continue;
                }
                //记录下Id为rule的View的被依赖关系
                dependency.dependents.put(node, this);
		//记录下当前View的依赖关系
                node.dependencies.put(rule, dependency);
            }
        }
    }

    final ArrayDeque<Node> roots = mRoots;
    roots.clear();

    //找到所有相对依赖关系为空的View，他们就是Roots
    for (int i = 0; i < count; i++) {
        final Node node = nodes.get(i);
        if (node.dependencies.size() == 0) roots.addLast(node);
    }

    return roots;
}

上面的例子中，Roots分别如下：

竖直：

A、C、D

水平：

找到了Roots，再看看是如何根据这些Roots来生成水平和垂直方向的排序规则的，

/**
   生成排序后的数组，排序规则如下，如果C依赖于A，而A依赖于B，那么排序就为 B -> A -> C。
 */
void getSortedViews(View[] sorted, int... rules) {
	//查找所有Roots
    final ArrayDeque<Node> roots = findRoots(rules);
    int index = 0;

    Node node;
	//从Roots的队列尾部取出View
    while ((node = roots.pollLast()) != null) {
        final View view = node.view;
        final int key = view.getId();
        //放置到排序数组的前面
        sorted[index++] = view;
		//拿到所有依赖于该View的View
        final ArrayMap<Node, DependencyGraph> dependents = node.dependents;
        final int count = dependents.size();
        for (int i = 0; i < count; i++) {
			//拿到依赖于该View的View
            final Node dependent = dependents.keyAt(i);
            final SparseArray<Node> dependencies = dependent.dependencies;
			//移除对该View的依赖
            dependencies.remove(key);
			//如果对该View依赖的View，已经没有其他依赖关系了，那么他也就成为一个新的Roots
            if (dependencies.size() == 0) {
                roots.add(dependent);
            }
        }
    }
	//循环依赖的检测，非法的
    if (index < sorted.length) {
        throw new IllegalStateException("Circular dependencies cannot exist"
                + " in RelativeLayout");
    }
}

上述例子中，这两个数组最后的值为：

mSortedHorizontalChildren：[D、B、C、A]

mSortedVerticalChildren：[A、D、B、C]

有了这两个数组，就可以欢乐的进行 measure、layout 了。