Android 框架会在 Activity 获得焦点时请求 Activity 绘制其布局。Android 框架会处理绘制流程，但该 Activity 必须提供其布局层次结构的根节点。
Android 框架会绘制布局的根节点，并测量和绘制布局树。它会通过遍历布局树并渲染与无效区域相交的每个 View 进行绘制。每个 ViewGroup 负责请求绘制其每个子级（使用 draw() 方法），而每个 View 负责绘制其本身。由于布局树已经过系统预先遍历，因此该框架会在子级之前（即后方）绘制父级，而其同级会按照它们在布局树中出现的顺序进行绘制。
Android 框架绘制布局包含两个遍历流程：一个测量遍历和一个布局遍历。该框架会在 measure(int, int) 中执行测量遍历，并执行 View 树的自上而下遍历。在递归过程中，每个 View 都会将维度规范下推到布局树。测量遍历结束时，每个 View 都会存储其测量值。该框架会在 layout(int, int, int, int) 中执行第二次遍历，也是自上而下遍历。在此次遍历中，每个父级负责使用测量遍历中计算的尺寸来定位其所有的子级。
以下各部分更详细地介绍了布局流程的两个遍历。
启动测量遍历
当返回 View 对象的 measure() 方法时，请设置其 getMeasuredWidth() 和 getMeasuredHeight() 值，以及 View 对象的所有后代的值。View 对象的测量宽度值和测量高度值必须遵守 View 对象的父级所施加的限制。这有助于保证在测量遍历结束时，所有父级都会接受其子级的所有测量值。
父级 View 可以对其子级多次调用 measure()。例如，父级可以使用未指定的维度测量子级一次，以确定它们的首选尺寸。如果子级的不受限尺寸的总和过大或过小，则父级可以使用限制子级尺寸的值再次调用 measure()。
测量遍历使用两个类来传达维度。View 对象使用 ViewGroup.LayoutParams 来传达其首选尺寸和位置。基本 ViewGroup.LayoutParams 类描述了 View 的首选宽度和高度。针对每个维度，它可以指定以下某一项：
- 一个确切的尺寸。
MATCH_PARENT，此参数意味着View的首选尺寸是其父级的尺寸（负填充）。WRAP_CONTENT，此参数意味着View的首选尺寸恰好足以容纳其内容（正填充）。
有适用于 ViewGroup 的不同子类的 ViewGroup.LayoutParams 子类。例如，RelativeLayout 有自己的 ViewGroup.LayoutParams 子类，其中包括可使子级 View 对象水平居中和垂直居中的功能。
MeasureSpec 对象用于在树中将要求从父级下推到子级。MeasureSpec 可以是下述三种模式之一：
UNSPECIFIED：父级使用此模式来确定子级View的目标维度。例如，LinearLayout可对高度设置为UNSPECIFIED且宽度设置为EXACTLY240 的子级调用measure()，以确定给定宽度为 240 像素的子级View所需的高度。EXACTLY：父级使用此模式来强制子级使用某个确切尺寸。子级必须使用此尺寸，并保证其所有的后代都能放入此尺寸。AT MOST：父级使用此模式来强制规定子级的最大尺寸。子级必须保证它及其所有的后代都能放入此尺寸。
启动布局遍历
如需启动布局，请调用 requestLayout()。当 View 认为自己无法再放入当前范围时，通常会调用此方法。
实现自定义测量和布局逻辑
如果您要实现自定义测量或布局逻辑，请替换实现该逻辑的方法：onMeasure(int, int) 和 onLayout(boolean, int, int, int, int)。
这些方法分别由 measure(int, int) 和 layout(int, int, int, int) 调用。请勿尝试替换 measure(int, int) 或 layout(int, int) 方法 - 这两种方法都是 final，因此无法被替换。
以下示例展示了如何在 WindowManager 示例应用的 `SplitLayout` 类中执行此操作。如果 SplitLayout 有两个或更多子视图，并且显示屏有折叠边，那么它会将两个子视图放置在折叠边的任一侧。以下示例展示了用于替换测量和布局的用例，但对于生产环境，请使用 SlidingPaneLayout（如果您希望出现此行为）。
Kotlin
/**
* An example of split-layout for two views, separated by a display
* feature that goes across the window. When both start and end views are
* added, it checks whether there are display features that separate the area
* in two—such as a fold or hinge—and places them side-by-side or
* top-bottom.
*/
class SplitLayout : FrameLayout {
private var windowLayoutInfo: WindowLayoutInfo? = null
private var startViewId = 0
private var endViewId = 0
private var lastWidthMeasureSpec: Int = 0
private var lastHeightMeasureSpec: Int = 0
...
fun updateWindowLayout(windowLayoutInfo: WindowLayoutInfo) {
this.windowLayoutInfo = windowLayoutInfo
requestLayout()
}
override fun onLayout(changed: Boolean, left: Int, top: Int, right: Int, bottom: Int) {
val startView = findStartView()
val endView = findEndView()
val splitPositions = splitViewPositions(startView, endView)
if (startView != null && endView != null && splitPositions != null) {
val startPosition = splitPositions[0]
val startWidthSpec = MeasureSpec.makeMeasureSpec(startPosition.width(), EXACTLY)
val startHeightSpec = MeasureSpec.makeMeasureSpec(startPosition.height(), EXACTLY)
startView.measure(startWidthSpec, startHeightSpec)
startView.layout(
startPosition.left, startPosition.top, startPosition.right,
startPosition.bottom
)
val endPosition = splitPositions[1]
val endWidthSpec = MeasureSpec.makeMeasureSpec(endPosition.width(), EXACTLY)
val endHeightSpec = MeasureSpec.makeMeasureSpec(endPosition.height(), EXACTLY)
endView.measure(endWidthSpec, endHeightSpec)
endView.layout(
endPosition.left, endPosition.top, endPosition.right,
endPosition.bottom
)
} else {
super.onLayout(changed, left, top, right, bottom)
}
}
/**
* Gets the position of the split for this view.
* @return A rect that defines of split, or {@code null} if there is no split.
*/
private fun splitViewPositions(startView: View?, endView: View?): Array? {
if (windowLayoutInfo == null || startView == null || endView == null) {
return null
}
// Calculate the area for view's content with padding.
val paddedWidth = width - paddingLeft - paddingRight
val paddedHeight = height - paddingTop - paddingBottom
windowLayoutInfo?.displayFeatures
?.firstOrNull { feature -> isValidFoldFeature(feature) }
?.let { feature ->
getFeaturePositionInViewRect(feature, this)?.let {
if (feature.bounds.left == 0) { // Horizontal layout.
val topRect = Rect(
paddingLeft, paddingTop,
paddingLeft + paddedWidth, it.top
)
val bottomRect = Rect(
paddingLeft, it.bottom,
paddingLeft + paddedWidth, paddingTop + paddedHeight
)
if (measureAndCheckMinSize(topRect, startView) &&
measureAndCheckMinSize(bottomRect, endView)
) {
return arrayOf(topRect, bottomRect)
}
} else if (feature.bounds.top == 0) { // Vertical layout.
val leftRect = Rect(
paddingLeft, paddingTop,
it.left, paddingTop + paddedHeight
)
val rightRect = Rect(
it.right, paddingTop,
paddingLeft + paddedWidth, paddingTop + paddedHeight
)
if (measureAndCheckMinSize(leftRect, startView) &&
measureAndCheckMinSize(rightRect, endView)
) {
return arrayOf(leftRect, rightRect)
}
}
}
}
// You previously tried to fit the children and measure them. Since they
// don't fit, measure again to update the stored values.
measure(lastWidthMeasureSpec, lastHeightMeasureSpec)
return null
}
override fun onMeasure(widthMeasureSpec: Int, heightMeasureSpec: Int) {
super.onMeasure(widthMeasureSpec, heightMeasureSpec)
lastWidthMeasureSpec = widthMeasureSpec
lastHeightMeasureSpec = heightMeasureSpec
}
/**
* Measures a child view and sees if it fits in the provided rect.
* This method calls [View.measure] on the child view, which updates its
* stored values for measured width and height. If the view ends up with
* different values, measure again.
*/
private fun measureAndCheckMinSize(rect: Rect, childView: View): Boolean {
val widthSpec = MeasureSpec.makeMeasureSpec(rect.width(), AT_MOST)
val heightSpec = MeasureSpec.makeMeasureSpec(rect.height(), AT_MOST)
childView.measure(widthSpec, heightSpec)
return childView.measuredWidthAndState and MEASURED_STATE_TOO_SMALL == 0 &&
childView.measuredHeightAndState and MEASURED_STATE_TOO_SMALL == 0
}
private fun isValidFoldFeature(displayFeature: DisplayFeature) =
(displayFeature as? FoldingFeature)?.let { feature ->
getFeaturePositionInViewRect(feature, this) != null
} ?: false
}
Java
/**
* An example of split-layout for two views, separated by a display feature
* that goes across the window. When both start and end views are added, it checks
* whether there are display features that separate the area in two—such as
* fold or hinge—and places them side-by-side or top-bottom.
*/
public class SplitLayout extends FrameLayout {
@Nullable
private WindowLayoutInfo windowLayoutInfo = null;
private int startViewId = 0;
private int endViewId = 0;
private int lastWidthMeasureSpec = 0;
private int lastHeightMeasureSpec = 0;
...
void updateWindowLayout(WindowLayoutInfo windowLayoutInfo) {
this.windowLayoutInfo = windowLayoutInfo;
requestLayout();
}
@Override
protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
@Nullable
View startView = findStartView();
@Nullable
View endView = findEndView();
@Nullable
List splitPositions = splitViewPositions(startView, endView);
if (startView != null && endView != null && splitPositions != null) {
Rect startPosition = splitPositions.get(0);
int startWidthSpec = MeasureSpec.makeMeasureSpec(startPosition.width(), EXACTLY);
int startHeightSpec = MeasureSpec.makeMeasureSpec(startPosition.height(), EXACTLY);
startView.measure(startWidthSpec, startHeightSpec);
startView.layout(
startPosition.left,
startPosition.top,
startPosition.right,
startPosition.bottom
);
Rect endPosition = splitPositions.get(1);
int endWidthSpec = MeasureSpec.makeMeasureSpec(endPosition.width(), EXACTLY);
int endHeightSpec = MeasureSpec.makeMeasureSpec(endPosition.height(), EXACTLY);
startView.measure(endWidthSpec, endHeightSpec);
startView.layout(
endPosition.left,
endPosition.top,
endPosition.right,
endPosition.bottom
);
} else {
super.onLayout(changed, left, top, right, bottom);
}
}
/**
* Gets the position of the split for this view.
* @return A rect that defines of split, or {@code null} if there is no split.
*/
@Nullable
private List splitViewPositions(@Nullable View startView, @Nullable View endView) {
if (windowLayoutInfo == null || startView == null || endView == null) {
return null;
}
int paddedWidth = getWidth() - getPaddingLeft() - getPaddingRight();
int paddedHeight = getHeight() - getPaddingTop() - getPaddingBottom();
List displayFeatures = windowLayoutInfo.getDisplayFeatures();
@Nullable
DisplayFeature feature = displayFeatures
.stream()
.filter(item ->
isValidFoldFeature(item)
)
.findFirst()
.orElse(null);
if (feature != null) {
Rect position = SampleToolsKt.getFeaturePositionInViewRect(feature, this, true);
Rect featureBounds = feature.getBounds();
if (featureBounds.left == 0) { // Horizontal layout.
Rect topRect = new Rect(
getPaddingLeft(),
getPaddingTop(),
getPaddingLeft() + paddedWidth,
position.top
);
Rect bottomRect = new Rect(
getPaddingLeft(),
position.bottom,
getPaddingLeft() + paddedWidth,
getPaddingTop() + paddedHeight
);
if (measureAndCheckMinSize(topRect, startView) &&
measureAndCheckMinSize(bottomRect, endView)) {
ArrayList rects = new ArrayList();
rects.add(topRect);
rects.add(bottomRect);
return rects;
}
} else if (featureBounds.top == 0) { // Vertical layout.
Rect leftRect = new Rect(
getPaddingLeft(),
getPaddingTop(),
position.left,
getPaddingTop() + paddedHeight
);
Rect rightRect = new Rect(
position.right,
getPaddingTop(),
getPaddingLeft() + paddedWidth,
getPaddingTop() + paddedHeight
);
if (measureAndCheckMinSize(leftRect, startView) &&
measureAndCheckMinSize(rightRect, endView)) {
ArrayList rects = new ArrayList();
rects.add(leftRect);
rects.add(rightRect);
return rects;
}
}
}
// You previously tried to fit the children and measure them. Since
// they don't fit, measure again to update the stored values.
measure(lastWidthMeasureSpec, lastHeightMeasureSpec);
return null;
}
@Override
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
super.onMeasure(widthMeasureSpec, heightMeasureSpec);
lastWidthMeasureSpec = widthMeasureSpec;
lastHeightMeasureSpec = heightMeasureSpec;
}
/**
* Measures a child view and sees if it fits in the provided rect.
* This method calls [View.measure] on the child view, which updates
* its stored values for measured width and height. If the view ends up with
* different values, measure again.
*/
private boolean measureAndCheckMinSize(Rect rect, View childView) {
int widthSpec = MeasureSpec.makeMeasureSpec(rect.width(), AT_MOST);
int heightSpec = MeasureSpec.makeMeasureSpec(rect.height(), AT_MOST);
childView.measure(widthSpec, heightSpec);
return (childView.getMeasuredWidthAndState() & MEASURED_STATE_TOO_SMALL) == 0 &&
(childView.getMeasuredHeightAndState() & MEASURED_STATE_TOO_SMALL) == 0;
}
private boolean isValidFoldFeature(DisplayFeature displayFeature) {
if (displayFeature instanceof FoldingFeature) {
return SampleToolsKt.getFeaturePositionInViewRect(displayFeature, this, true) != null;
} else {
return false;
}
}
}