Platforma Androida prosi Activity
o rysowanie układu, gdy obiekt Activity
jest zaznaczony. Platforma Android obsługuje procedurę rysowania, ale Activity
musi podać węzeł główny swojej hierarchii układu.
Platforma Androida pobiera węzeł główny układu, dokonuje pomiarów i rysuje drzewo układu. Wyświetla się przez przeszukiwanie drzewa i renderowanie każdego węzła View
, który przecina nieprawidłowy region.
Każdy element ViewGroup
odpowiada za żądanie narysowania wszystkich swoich elementów podrzędnych za pomocą metody draw()
, a każdy element View
odpowiada za narysowanie samego siebie. Ponieważ drzewo jest przemierzane w kolejności wstępnej, framework rysuje elementy nadrzędne przed elementami podrzędnymi (czyli za nimi) oraz elementy siostrzane w kolejności, w jakiej występują w drzewie.
Platforma Android rysuje układ w 2 etapach: pomiar i układ. Framework wykonuje pomiar w measure(int, int)
i przechodzi od góry do dołu po drzewie View
. Każdy element View
przesuwa specyfikacje wymiarów w dół drzewa podczas rekurencji. Na końcu zaliczenia testu każdy View
zapisuje swoje pomiary. Drugi przejazd frameworku jest wykonywany w trybie layout(int, int, int, int)
i także od góry do dołu. W tym procesie każdy wydawca nadrzędny odpowiada za umieszczenie wszystkich swoich elementów podrzędnych przy użyciu rozmiarów obliczonych w ramach pomiarów.
Dwa etapy procesu tworzenia układu opisujemy bardziej szczegółowo w kolejnych sekcjach.
Rozpocznij procedurę zaliczania pomiarów
Gdy metoda measure()
obiektu View
zwraca wartość, ustaw wartości getMeasuredWidth()
i getMeasuredHeight()
, a także wartości wszystkich potomków obiektu View
. Zmierzone wartości szerokości i wysokości obiektu View
muszą być zgodne z ograniczeniami narzuconymi przez nadrzędne obiektu View
. Dzięki temu na koniec okresu pomiarowego wszyscy rodzice zaakceptują wszystkie pomiary swoich dzieci.
Rodzic View
może wywołać measure()
więcej niż raz w przypadku swoich dzieci. Na przykład element nadrzędny może raz mierzyć elementy podrzędne z nieokreślonymi wymiarami, aby określić preferowane rozmiary. Jeśli suma nieograniczonych rozmiarów podrzędnych jest zbyt duża lub zbyt mała, element nadrzędny może ponownie wywołać funkcję measure()
, podając wartości, które ograniczają rozmiary podrzędne.
Przekaz pomiaru używa 2 klas do przekazywania wymiarów. Klasa ViewGroup.LayoutParams
informuje obiekty View
o ich preferowanych rozmiarach i pozycjach. Podstawowa klasa ViewGroup.LayoutParams
określa preferowaną szerokość i wysokość klasy View
. W przypadku każdego wymiaru możesz określić jedną z tych opcji:
- Dokładny wymiar.
MATCH_PARENT
, co oznacza, że preferowany rozmiar dlaView
to rozmiar jego elementu nadrzędnego pomniejszony o odstęp.WRAP_CONTENT
, co oznacza, że preferowany rozmiarView
jest wystarczająco duży, aby pomieścić jego zawartość, oraz odstęp.
Istnieją podklasy ViewGroup.LayoutParams
dla różnych podklas ViewGroup
. Na przykład RelativeLayout
ma własną podklasę klasy ViewGroup.LayoutParams
, która umożliwia wyśrodkowanie obiektów podrzędnych View
w poziomie i w pionie.
Obiekty MeasureSpec
są używane do przenoszenia wymagań z drzewa nadrzędnego na element podrzędny. MeasureSpec
może mieć jeden z 3 trybów:
UNSPECIFIED
: element nadrzędny używa tego parametru do określania docelowej wymiary podrzędnegoView
. Na przykładLinearLayout
może wywołaćmeasure()
na swoim dziecku, ustawiając wysokość naUNSPECIFIED
, a szerokość naEXACTLY
240, aby dowiedzieć się, jak wysoki chce byćView
, biorąc pod uwagę szerokość 240 pikseli.EXACTLY
: rodzic używa tego, aby narzucić dokładny rozmiar na element podrzędny. Dziecko musi używać tego rozmiaru i gwarantować, że wszystkie jego potomki mieszczą się w tym rozmiarze.AT MOST
: element nadrzędny używa tego atrybutu do narzucenia maksymalnego rozmiaru elementowi podrzędnemu. Podmiot podrzędny musi zagwarantować, że on sam i wszystkie jego potomkowie mieszczą się w tym rozmiarze.
Rozpoczęcie przechodzenia przez układ
Aby zainicjować układ, wywołaj requestLayout()
. Ta metoda jest zwykle wywoływana przez View
, gdy uważa, że nie mieści się już w swoich granicach.
Implementowanie niestandardowych pomiarów i logiki układu
Jeśli chcesz wdrożyć niestandardowy pomiar lub logikę układu, zastąp metody implementacji tej logiki: onMeasure(int, int)
i onLayout(boolean, int, int, int, int)
.
Te metody są wywoływane odpowiednio przez measure(int, int)
i layout(int, int, int, int)
. Nie próbuj zastąpić metod measure(int, int)
ani layout(int, int)
, ponieważ obie są metodami final
, co oznacza, że nie można ich zastąpić.
Poniższy przykład pokazuje, jak to zrobić w klasie `SplitLayout` z aplikacji WindowManager. Jeśli widok SplitLayout
ma co najmniej 2 podrzędne widoki, a ekran jest złożony, widoki te są umieszczane po obu stronach zagięcia. Poniższy przykład pokazuje przypadek użycia, w którym zastąpiono pomiar i rozmieszczenie, ale w produkcji użyj parametru SlidingPaneLayout
, jeśli chcesz uzyskać takie działanie.
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; } } }