Das Android-Framework fordert ein Activity auf, sein Layout zu zeichnen, wenn das Activity hervorgehoben wird. Das Android-Framework übernimmt das Zeichnen, aber Activity muss den Stammknoten seiner Layouthierarchie bereitstellen.
Das Android-Framework zeichnet den Stammknoten des Layouts und misst und gezeichnet den Layoutbaum. Zum Zeichnen wird der Baum ausgeführt und jeder View gerendert, der sich mit der ungültigen Region schneidet.
Jede ViewGroup fordert mithilfe der Methode draw() an, dass jedes ihrer untergeordneten Elemente gezeichnet wird. Jedes View-Element ist dann für die Zeichnung selbst verantwortlich. Da der Baum vor Reihenfolge durchlaufen wird, zieht das Framework Eltern vor – mit anderen Worten hinter ihren Kindern an und zieht Geschwister in der Reihenfolge an, in der sie im Baum vorkommen.
Das Android-Framework zeichnet das Layout in einem Prozess mit zwei Durchgängen: einer Messung und einem Layout-Pass. Das Framework führt die Messungsübergabe in measure(int, int) und einen Top-down-Durchlauf des Baums View durch. Jeder View verschiebt die Dimensionsspezifikationen während der Rekursion den Baum nach unten. Am Ende der Messungskarte speichert jeder View seine Messungen. Das Framework führt den zweiten Durchlauf in layout(int, int, int, int) durch und ist ebenfalls von oben nach unten. Während dieses Durchlaufs ist jedes übergeordnete Element dafür verantwortlich, alle seine untergeordneten Elemente anhand der in der Messungsdurchführung berechneten Größen zu positionieren.
Die beiden Durchgänge des Layoutprozesses werden in den folgenden Abschnitten ausführlicher beschrieben.
Messungspass starten
Wenn die Methode measure() eines View-Objekts zurückgegeben wird, legen Sie die Werte für getMeasuredWidth() und getMeasuredHeight() zusammen mit denen für alle untergeordneten Elemente des View-Objekts fest. Bei den gemessenen Werten für Breite und Höhe eines View-Objekts müssen die Einschränkungen berücksichtigt werden, die von den übergeordneten Elementen des View-Objekts auferlegt werden. So wird sichergestellt, dass am Ende des Messpasses alle Eltern alle Messungen ihrer Kinder akzeptieren.
Ein übergeordnetes View-Element ruft für seine untergeordneten Elemente möglicherweise mehrmals measure() auf. Das übergeordnete Element könnte beispielsweise die untergeordneten Elemente einmal mit nicht angegebenen Abmessungen messen, um ihre bevorzugten Größen zu ermitteln. Wenn die Summe der nicht eingeschränkten Größen der untergeordneten Elemente zu groß oder zu klein ist, ruft das übergeordnete Element möglicherweise noch einmal measure() mit Werten auf, die die Größen der untergeordneten Elemente einschränken.
Die Messungskarte verwendet zwei Klassen, um Dimensionen zu kommunizieren. Mit der Klasse ViewGroup.LayoutParams kommunizieren View-Objekte ihre bevorzugten Größen und Positionen. Die Basisklasse ViewGroup.LayoutParams beschreibt die bevorzugte Breite und Höhe des View. Für jede Dimension kann eine der folgenden Optionen angegeben werden:
- Eine genaue Dimension.
MATCH_PARENT: Die bevorzugte Größe fürViewist also die Größe des übergeordneten Elements abzüglich des Abstands.WRAP_CONTENT, was bedeutet, dass die bevorzugte Größe fürViewgerade groß genug ist, um den Inhalt zu umschließen, plus Abstand.
Es gibt abgeleitete Klassen von ViewGroup.LayoutParams für verschiedene abgeleitete Klassen von ViewGroup. RelativeLayout hat beispielsweise eine eigene Unterklasse von ViewGroup.LayoutParams, mit der untergeordnete View-Objekte horizontal und vertikal zentriert werden können.
MeasureSpec-Objekte werden verwendet, um Anforderungen in der Baumstruktur von den übergeordneten in die untergeordnete Organisation zu verschieben. Eine MeasureSpec kann in einem von drei Modi vorliegen:
UNSPECIFIED: Das übergeordnete Element verwendet dieses Attribut, um die Zieldimension eines untergeordnetenView-Elements zu bestimmen. Zum Beispiel könnte einLinearLayoutmeasure()für sein untergeordnetes Element mit der HöheUNSPECIFIEDund einer Breite vonEXACTLY240 für sein untergeordnetes Element aufrufen, um herauszufinden, wie hoch das untergeordnete ElementViewbei einer Breite von 240 Pixel sein möchte.EXACTLY: Das übergeordnete Element verwendet dies, um dem untergeordneten Element eine genaue Größe festzulegen. Das untergeordnete Element muss diese Größe verwenden und dafür sorgen, dass alle Nachfolgerelemente diese Größe einhalten.AT MOST: Das übergeordnete Element verwendet dies, um eine maximale Größe für das untergeordnete Element festzulegen. Das untergeordnete Element muss sicherstellen, dass es und alle Nachfolgerelemente dieser Größe entsprechen.
Layout-Pass initiieren
Um ein Layout zu initiieren, rufen Sie requestLayout() auf. Diese Methode wird normalerweise von einem View selbst aufgerufen, wenn die Methode der Meinung ist, dass sie nicht mehr in ihre Grenzen passt.
Benutzerdefinierte Mess- und Layoutlogik implementieren
Wenn Sie eine benutzerdefinierte Mess- oder Layoutlogik implementieren möchten, überschreiben Sie die Methoden mit der entsprechenden Logik: onMeasure(int, int) und onLayout(boolean, int, int, int, int).
Diese Methoden werden von measure(int, int) bzw. layout(int, int, int, int) aufgerufen. Versuchen Sie nicht, die Methoden measure(int, int) und layout(int, int) zu überschreiben – beide Methoden sind final, sodass sie nicht überschrieben werden können.
Das folgende Beispiel zeigt, wie dies in der Klasse `SplitLayout` aus der Beispiel-App WindowManager funktioniert. Wenn SplitLayout zwei oder mehr untergeordnete Ansichten hat und der Bildschirm umgeklappt ist, werden die beiden untergeordneten Ansichten auf beiden Seiten des sichtbaren Bereichs positioniert. Das folgende Beispiel zeigt einen Anwendungsfall für das Überschreiben der Messung und des Layouts. In der Produktion sollten Sie SlidingPaneLayout verwenden, wenn Sie dieses Verhalten wünschen.
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;
}
}
}