Das Android-Framework verlangt einen
Activity
, um das Layout zu zeichnen, wenn die
Activity
erhält Fokus. Das Android-Framework übernimmt das Zeichnen, aber der
Activity
muss den Stammknoten seiner Layouthierarchie angeben.
Das Android-Framework zeichnet den Stammknoten des Layouts und misst und zeichnet den Layoutbaum. Es
indem wir den Baum durchgehen und jedes
View
, die sich mit der ungültigen Region überschneidet.
Jeder ViewGroup
ist verantwortlich für
fordern, dass jedes seiner untergeordneten Elemente gezeichnet wird. Dazu wird der Operator
draw()
und jeder View
ist für die Zeichnung selbst verantwortlich. Weil der Baum durchquert wird
Vorbestellungen erfolgen, zieht das Framework die Eltern vor – mit anderen Worten – hinter ihrem
untergeordnete Elemente und zeichnet gleichgeordnete Elemente in der Reihenfolge, in der sie in der Baumstruktur angezeigt werden.
Das Android-Framework zeichnet das Layout in einem Prozess mit zwei Durchgängen: einer Messungsübergabe und einer Layoutübergabe. Die
das Framework die Messübergabe
measure(int, int)
und
führt einen Top-down-Durchlauf des View
-Baums durch. Jede View
überträgt eine Dimension.
Spezifikationen des Baums während der Rekursion. Am Ende der Messung
View
speichert seine Messwerte. Das Framework führt den zweiten Durchlauf
layout(int, int, int, int)
und ist ebenfalls von oben nach unten. Während dieser Zeit ist jedes übergeordnete Element für die Positionierung aller untergeordneten Elemente verantwortlich
mithilfe der Größen, die in der Messungsdurchführung berechnet wurden.
Die beiden Durchgänge des Layoutprozesses werden in den folgenden Abschnitten ausführlicher beschrieben.
Bestandene Messung starten
Wenn die Eigenschaft eines View
-Objekts
measure()
-Methode
gibt, legen Sie die
getMeasuredWidth()
und
getMeasuredHeight()
-Werte sowie denen für alle Nachfolgerelemente des View
-Objekts. Ein View
müssen die Werte der gemessenen Breite und Höhe des Objekts die
Die übergeordneten Elemente des View
-Objekts. So sorgen Sie dafür, dass am Ende der Messung alle
alle Messungen ihrer Kinder akzeptieren.
Ein übergeordnetes View
-Element kann measure()
für seine untergeordneten Elemente mehrmals aufrufen. Für
Beispiel: Das übergeordnete Element kann die untergeordneten Elemente einmal mit nicht angegebenen Dimensionen messen, um ihre
bevorzugte Größen. Wenn die Summe der nicht eingeschränkten Größen der untergeordneten Elemente zu groß oder zu klein ist,
kann measure()
erneut mit Werten aufrufen, die die Größen der untergeordneten Elemente einschränken.
Bei der Messungskarte werden zwei Klassen verwendet, um Dimensionen zu kommunizieren. Die
ViewGroup.LayoutParams
ist die Methode, mit der View
-Objekte ihre bevorzugten Größen und Positionen kommunizieren. Basis
ViewGroup.LayoutParams
-Klasse 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
, d. h. die bevorzugte Größe fürView
ist die Größe des übergeordneten Elements, minus Abstand.WRAP_CONTENT
, Das heißt, die bevorzugte Größe fürView
ist gerade groß genug, um den Inhalt zu einschließen, hinzufügen.
Es gibt abgeleitete Klassen von ViewGroup.LayoutParams
für verschiedene abgeleitete Klassen von
ViewGroup
. Beispiel:
RelativeLayout
hat eine eigene
von ViewGroup.LayoutParams
mit der Möglichkeit, untergeordnete Elemente
View
-Objekte horizontal und vertikal.
MeasureSpec
Objekte sind
werden verwendet, um Anforderungen in der Baumstruktur von der übergeordneten in die untergeordnete zu verschieben. Ein MeasureSpec
kann sich hier befinden:
einem von drei Modi:
UNSPECIFIED
: wird vom übergeordneten Element verwendet, um die Zieldimension eines untergeordnetenView
-Elements zu bestimmen. Beispiel: kann einLinearLayout
anrufen,measure()
für das untergeordnete Element mit einer Höhe vonUNSPECIFIED
und einer Breite vonEXACTLY
240 um zu ermitteln, wie groß das untergeordnete ElementView
bei einer Breite von 240 Pixeln sein möchte.EXACTLY
: wird dies vom übergeordneten Element verwendet, um dem untergeordneten Element eine genaue Größe vorzugeben. Das untergeordnete Element muss diese Größe und dass alle Nachfolgerelemente in diese Größe passen.AT MOST
: wird dies vom übergeordneten Element verwendet, um eine maximale Größe für das untergeordnete Element festzulegen. Das Kind muss dafür sorgen, dass alle Nachfolgerelemente in diese Größe passen.
Layoutübergabe initiieren
Rufen Sie zum Starten eines Layouts
requestLayout()
Dieses
wird normalerweise von einem View
selbst aufgerufen, wenn sie annimmt, dass sie nicht
die innerhalb der Grenzen liegt.
Benutzerdefinierte Mess- und Layoutlogik implementieren
Wenn Sie eine benutzerdefinierte Mess- oder Layoutlogik implementieren möchten, überschreiben Sie die Methoden, bei denen die Logik
implementiert wird:
onMeasure(int, int)
und
onLayout(boolean, int, int, int, int)
.
Diese Methoden werden von measure(int, int)
aufgerufen und
layout(int, int, int, int)
. Versuchen Sie nicht, die
measure(int, int)
- oder layout(int, int)
-Methode: beide Methoden
sind final
und können daher nicht überschrieben werden.
Das folgende Beispiel zeigt, wie dies in der
SplitLayout
Klasse aus der
Fenstermanager
Beispiel-App. Hat SplitLayout
zwei oder mehr untergeordnete Ansichten und das Display hat einen Fold,
werden die beiden untergeordneten
Ansichten links und rechts vom Fold positioniert. Das folgende Beispiel zeigt eine Verwendung
für das Überschreiben der Messung und das Layout,
SlidingPaneLayout
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 ListsplitPositions = 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; } } }