onLayout(): vad det är, algoritm för placering och metodparametrar

Vad är onLayout()?

onLayout(boolean changed, int l, int t, int r, int b) — är en protected metod i klassen ViewGroup som anropas av systemet för att positionera underordnade View inuti den föräldrade containern. Utvecklaren åsidosätter denna metod när han skapar en anpassad ViewGroup med en ostandardiserad arrangemang av element: i kaskad, rutnät, schackbrädesmönster eller enligt godtyckliga koordinater. Varje underordnat View får sina slutgiltiga gränser genom anropet child.layout().

Parametern changed anger om positionen eller storleken på själva ViewGroup har ändrats sedan den senaste layouten. Om changed är true behöver alla underordnade element troligen också ompositioneras. Parametrarna l, t, r, b är koordinaterna för ViewGroup-ets övre vänstra och nedre högra hörn i dess förälders koordinatsystem. Inuti onLayout använder utvecklaren dessa värden som startkoordinater för att placera barnen.

ViewGroup — är den enda klassen som åsidosätter onLayout. En vanlig View (inte ViewGroup) har inga underordnade element och behöver inte onLayout — dess egen positionering hanteras av den föräldrade containern. Även om en vanlig View åsidosätter onLayout kommer systemet inte att anropa den. Detta är den grundläggande skillnaden mellan onLayout och onMeasure, som anropas för varje View.

Utförandeflöde för layout-fasen

Layout-fasen börjar med anrop av den publika metoden layout(int l, int t, int r, int b) på rot-View. Denna metod anger de slutgiltiga koordinaterna för själva View och anropar onLayout om View är en ViewGroup. Därefter anropar onLayout rekursivt child.layout() för varje underordnat element, och processen upprepas nedåt i hierarkin. På så sätt sprids layout från roten till löven.

Före anrop av onLayout kontrollerar systemet om View-ets dimensioner har ändrats jämfört med föregående cykel. Om dimensionerna inte har ändrats och requestLayout inte har anropats, kanske onLayout inte anropas — systemet använder resultaten från den föregående layouten. Detta är en optimering som förhindrar onödiga omräkningar av positioner under animeringar eller scrollning, när endast innehållet ändras, inte dimensionerna.

requestLayout() — är en metod i View som informerar systemet om att View-ets layout är föråldrad och behöver omräknas. Anrop av requestLayout leder till en fullständig cykel: först anropas onMeasure, sedan onLayout, sedan onDraw. Till skillnad från invalidate, som endast startar omritning, startar requestLayout fullständig omräkning av dimensioner och positioner. Overdrivet anrop av requestLayout är en vanlig orsak till prestandaproblem.

Parametrar för onLayout: l, t, r, b

l (left) — X-koordinaten för vänsterkanten av ViewGroup i dess förälders koordinatsystem. t (top) — Y-koordinaten för överkanten. r (right) — X-koordinaten för högerkanten. b (bottom) — Y-koordinaten för nederkanten. Bredden på ViewGroup beräknas som r - l, höjden som b - t. Dessa koordinater inkluderar redan all padding för själva ViewGroup.

Inuti onLayout anropar utvecklaren child.layout(int childLeft, int childTop, int childRight, int childBottom) för varje underordnat View. Koordinaterna som skickas till child.layout måste vara i den föräldrade ViewGroup-ets koordinatsystem. Vanligtvis beräknas childLeft och childTop med hänsyn till förälderns padding: childLeft = l + paddingLeft + offsetX, childTop = t + paddingTop + offsetY.

Beräkning av koordinater för underordnade element

Underordnade koordinater beräknas enligt formeln: childLeft = l + paddingLeft + (marginLeft if present), childRight = childLeft + child.getMeasuredWidth(). Liknande för vertikalt: childTop = t + paddingTop + (marginTop), childBottom = childTop + child.getMeasuredHeight(). Efter beräkning av dessa fyra värden anropas child.layout(childLeft, childTop, childRight, childBottom).

Exempel på anpassad ViewGroup med onLayout i Kotlin

Låt oss skapa en FlowLayout — en anpassad ViewGroup som placerar underordnade View i rader och flyttar element till en ny rad när den aktuella raden är full. Detta är analogen till Flexbox med wrap i ett plan. onLayout itererar över alla underordnade View, beräknar positionen för varje och anropar child.layout() med korrekta gränser.

class FlowLayout(context: Context)
    : ViewGroup(context) {

    private val horizontalSpacing = 12
    private val verticalSpacing = 8

    override fun onMeasure(widthMeasureSpec: Int,
                       heightMeasureSpec: Int) {
        val parentWidth =
            MeasureSpec.getSize(widthMeasureSpec)
        var rowX = paddingLeft
        var rowY = paddingTop
        var maxRowHeight = 0

        for (i in 0 until childCount) {
            val child = getChildAt(i)
            measureChildWithMargins(child,
                widthMeasureSpec, 0,
                heightMeasureSpec, 0)

            if (rowX + child.measuredWidth >
                parentWidth - paddingRight) {
                rowX = paddingLeft
                rowY += maxRowHeight + verticalSpacing
                maxRowHeight = 0
            }

            rowX += child.measuredWidth +
                horizontalSpacing
            maxRowHeight = maxOf(maxRowHeight,
                child.measuredHeight)
        }

        val totalHeight = rowY + maxRowHeight +
            paddingBottom
        setMeasuredDimension(
            resolveSize(parentWidth, widthMeasureSpec),
            resolveSize(totalHeight, heightMeasureSpec))
    }

    override fun onLayout(changed: Boolean,
                       l: Int, t: Int,
                       r: Int, b: Int) {
        val parentWidth = r - l
        var rowX = paddingLeft
        var rowY = paddingTop
        var maxRowHeight = 0

        for (i in 0 until childCount) {
            val child = getChildAt(i)
            val cw = child.measuredWidth
            val ch = child.measuredHeight

            if (rowX + cw >
                parentWidth - paddingRight) {
                rowX = paddingLeft
                rowY += maxRowHeight + verticalSpacing
                maxRowHeight = 0
            }

            child.layout(rowX, rowY,
                rowX + cw, rowY + ch)
            rowX += cw + horizontalSpacing
            maxRowHeight =
                maxOf(maxRowHeight, ch)
        }
    }

    override fun generateLayoutParams(attrs: AttributeSet?)
        : LayoutParams =
        MarginLayoutParams(context, attrs)
}

Skillnader mellan onLayout och onMeasure

onMeasure och onLayout — är två på varandra följande faser i View-ets livscykel som utför fundamentalt olika uppgifter. onMeasure bestämmer önskade (measured) dimensioner för View, medan onLayout anger faktiska (actual) koordinater och dimensioner. Den viktigaste skillnaden: i onMeasure kan dimensionerna vara tillfälliga och senare korrigeras av föräldern, medan i onLayout fastställs den slutgiltiga positionen för varje underordnat View.

onMeasure anropas för varje View, inklusive löv-View (TextView, ImageView, Button). onLayout anropas endast för ViewGroup. Detta förklaras av att positionering är den föräldrade containerns ansvar, inte själva View-ets. Ett löv-View får sin position genom layout() anropat från förälderns onLayout.

getMeasuredWidth() och getMeasuredHeight() är tillgängliga efter onMeasure, medan getWidth() och getHeight() — först efter onLayout. Om du kommer åt getWidth() inuti onMeasure kommer värdet från den föregående cykeln eller noll att returneras. Därför bör du använda MeasureSpec och successivt children för att beräkna dimensioner i onMeasure.

Typiska misstag vid arbete med onLayout

Positionering utan hänsyn till padding — första misstaget vid implementering av onLayout. Utvecklaren glömmer ofta att lägga till förälderns paddingLeft och paddingTop till startkoordinaterna för underordnade View. Som ett resultat visas barnen vid kanten av ViewGroup, utan att ta hänsyn till mellanrum som angetts via setPadding() eller i XML. Korrekt beräkning: childLeft = paddingLeft + offsetX.

Anropa layout för osynliga barn — det andra vanliga problemet. Om ViewGroup innehåller underordnade View med visibility lika med GONE, behöver de inte positioneras — de tar inte upp plats. Dock måste onLayout hantera detta fall korrekt genom att hoppa över GONE-barn. För INVISIBLE-barn måste layout fortfarande anropas — de behåller sin plats även om de inte visas.

Ignorera parametern changed — tredje misstaget. Parametern changed anger om ViewGroup-ets dimensioner eller position har ändrats. Om changed == false kan cachade koordinater användas och layout av alla underordnade element behöver inte omberäknas. Fullständig cachning av layout är dock en svår uppgift och de flesta implementeringar av onLayout omberäknar helt enkelt alla element varje gång. Detta är acceptabelt vid ett litet antal barn.