Gdy Activity
otrzyma fokus, framework Androida poprosi Activity
o narysowanie układu. Procedurę rysowania wykonuje platforma Androida, ale Activity
musi zapewniać węzeł główny hierarchii układu.
Platforma Androida pobiera węzeł główny układu, dokonuje pomiarów i rysuje drzewo układu. Rysuje się, spacerując po drzewie i renderując każdy element View
, który przecina nieprawidłowy region.
Każdy element ViewGroup
odpowiada za żądanie narysowania każdego ze swoich elementów podrzędnych za pomocą metody draw()
, a każdy element View
odpowiada za rysowanie. 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 Androida rysuje układ w ramach procesu dwuetapowego: zaliczenia testu i zaliczenia układu. Platforma wykonuje przekazywanie pomiaru w narzędziu measure(int, int)
i przeprowadza od góry drzewo View
. Każdy obiekt View
przenosi specyfikację wymiaru w dół drzewa podczas rekurencji. Po zakończeniu pomiaru każdy View
zapisuje wyniki pomiarów. Drugi przejazd frameworku jest wykonywany w trybie layout(int, int, int, int)
i także od góry do dołu. Podczas tego przejścia każdy element nadrzędny odpowiada za pozycjonowanie wszystkich elementów podrzędnych za pomocą rozmiarów obliczonych w przechodzeniu pomiarowym.
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 rodzic może zmierzyć dziecko za pomocą nieokreślonych wymiarów, aby określić preferowane rozmiary. Jeśli suma nieograniczonych rozmiarów elementów podrzędnych jest zbyt duża lub zbyt mała, element nadrzędny może ponownie wywołać funkcję measure()
z wartościami ograniczającymi rozmiary elementów podrzędnych.
Przekaz pomiaru używa 2 klas do przekazywania wymiarów. Klasa ViewGroup.LayoutParams
informuje obiekty View
o ich preferowanych rozmiarach i pozycjach. Klasa podstawowa ViewGroup.LayoutParams
opisuje preferowaną szerokość i wysokość elementu View
. W przypadku każdego wymiaru możesz określić jedną z tych opcji:
- Dokładny wymiar.
MATCH_PARENT
, co oznacza, że preferowany rozmiar elementuView
to rozmiar elementu nadrzędnego, pomniejszony o dopełnienie.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żą do przekazywania wymagań w dół drzewa od elementu nadrzędnego do podrzędnego. MeasureSpec
może działać w jednym z 3 trybów:
UNSPECIFIED
: element nadrzędny na podstawie tej wartości określa wymiar docelowy elementu podrzędnegoView
. Na przykładLinearLayout
może wywołaćmeasure()
w elemencie podrzędnym z wysokością ustawioną naUNSPECIFIED
i szerokościąEXACTLY
240, aby dowiedzieć się, jaką wysokość chce mieć element podrzędnyView
przy szerokości 240 pikseli.EXACTLY
: element nadrzędny używa tej wartości, aby zastosować dokładny rozmiar do elementu podrzędnego. Wydawca podrzędny musi użyć tego rozmiaru i zagwarantować, że wszystkie jego elementy podrzędne mieszczą się w tym rozmiarze.AT MOST
: element nadrzędny używa tej wartości do nałożenia maksymalnego rozmiaru na element podrzędny. Podmiot podrzędny musi zagwarantować, że on sam i wszystkie jego potomkowie mieszczą się w tym rozmiarze.
Rozpoczęcie przechodzenia przez układ
Aby rozpocząć układ, wywołaj funkcję 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 zastępuj metod measure(int, int)
ani layout(int, int)
– obie te metody mają wartość final
, więc nie można ich zastąpić.
Z przykładu poniżej dowiesz się, jak to zrobić w klasie `SplitLayout` z przykładowej aplikacji WindowManager. Jeśli SplitLayout
ma co najmniej 2 widoki podrzędne, a ekran jest składany, dwa widoki podrzędne są umieszczone po obu stronach części strony widocznej na ekranie. 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; } } }