onMeasure(): какво е това, режими MeasureSpec и предефиниране на метода

Какво е onMeasure()?

onMeasure(int widthMeasureSpec, int heightMeasureSpec) — е методът на класа View, който системата Android извиква за определяне на ширината и височината на изгледа. Разработчикът предефинира този метод, за да посочи какъв размер трябва да има View въз основа на ограниченията, предадени в MeasureSpec. Без коректно предефиниране на onMeasure, персонализираният View може да се показва неправилно или изобщо да не се показва.

Системата извиква onMeasure във фазата measure от жизнения цикъл на View, която предшества фазите layout (onLayout) и draw (onDraw). Ако View не предефинира onMeasure, се използва имплементацията от суперкласа, която задава размери по подразбиране на базата на background drawable или layout_params. Извикването super.onMeasure(widthMeasureSpec, heightMeasureSpec) работи само за стандартни подкласове на View, като TextView или ImageView.

Ключовото изискване за onMeasure — извикването setMeasuredDimension(int, int) трябва задължително да присъства в края на метода. Ако това извикване липсва, системата генерира изключение IllegalStateException със съобщение, че View не е фиксирал измерените размери. Крайните размери стават достъпни чрез getter методите getMeasuredWidth() и getMeasuredHeight() след завършване на фазата measure.

Режими MeasureSpec: три ключови стойности

MeasureSpec — е 32-битово цяло число, в което горните 2 бита кодират режима на измерване, а долните 30 бита — размера. Режимът определя колко свободен е View в избора на своя размер. Android предоставя три режима: EXACTLY, AT_MOST и UNSPECIFIED. Всеки режим диктува различна логика на обработка в onMeasure.

За извличане на режима и размера от MeasureSpec се използват статичните методи на класа MeasureSpec: MeasureSpec.getMode(int) връща един от трите режима (EXACTLY, AT_MOST, UNSPECIFIED), а MeasureSpec.getSize(int) връща числовия размер в пиксели. За създаване на собствен MeasureSpec се използва MeasureSpec.makeMeasureSpec(int size, int mode). Тези три метода покриват всички сценарии за работа с размери в onMeasure.

Типична логика за обработка на MeasureSpec

Стандартен модел за обработка на MeasureSpec: ако режимът е EXACTLY — използвайте предадения размер като окончателен; ако е AT_MOST — изберете минимума от желания размер (съдържанието на View) и предадения максимум; ако е UNSPECIFIED — използвайте желания размер на View без ограничения. Този модел гарантира коректно поведение при всякакви ограничения на родителя.

override fun onMeasure(widthMeasureSpec: Int,
                       heightMeasureSpec: Int) {
    val desiredWidth = 200
    val desiredHeight = 100

    val widthMode = MeasureSpec.getMode(widthMeasureSpec)
    val widthSize = MeasureSpec.getSize(widthMeasureSpec)
    val heightMode = MeasureSpec.getMode(heightMeasureSpec)
    val heightSize = MeasureSpec.getSize(heightMeasureSpec)

    val width = when (widthMode) {
        MeasureSpec.EXACTLY -> widthSize
        MeasureSpec.AT_MOST -> minOf(desiredWidth, widthSize)
        else -> desiredWidth
    }
    val height = when (heightMode) {
        MeasureSpec.EXACTLY -> heightSize
        MeasureSpec.AT_MOST -> minOf(desiredHeight, heightSize)
        else -> desiredHeight
    }
    setMeasuredDimension(width, height)
}

Използване на resolveSize

За опростяване на стандартната логика Android предоставя метода resolveSizeAndState, който приема желания размер, MeasureSpec и връща крайния размер с коректен режим. Този метод имплементира описания по-горе модел в един ред код. Също така е налична функцията resolveSize(int size, int measureSpec), която връща чистия размер без state-битове.

Двупроходен алгоритъм за измерване

Android използва двупроходен алгоритъм за измерване (two-pass measure), който гарантира, че всеки View в йерархията получава коректни размери, като се вземат предвид ограниченията на родителя и предпочитанията на дъщерните елементи. На първия проход родителят предава на дъщерните View MeasureSpec с ограничения, а дъщерните View изчисляват своите желани размери. На втория проход родителят взема окончателно решение за размерите.

За ViewGroup процесът на измерване е по-сложен: родителят трябва първо да измери всички свои дъщерни елементи, след което да определи собствения си размер на базата на техните размери. Извикването measureChildren(int widthMeasureSpec, int heightMeasureSpec) обхожда всички дъщерни View и извиква за всяко measure(child, childWidthSpec, childHeightSpec). След измерване на всички дъщерни елементи, ViewGroup извиква setMeasuredDimension със своите размери.

Важен нюанс: методът measure (публичен, final) не може да бъде предефиниран — вместо него се предефинира onMeasure. Това гарантира, че системата може да извършва служебни действия преди и след извикването на onMeasure, като проверка на промяна на размерите и изчисляване на dirty-зоната за последващо рисуване. Ако View има фиксирани размери, предефинирането на onMeasure може да не е необходимо.

Флаг MEASURED_SIZE_STATE

MeasureSpec включва не само размера и режима, но и битове за състояние (state bits), достъпни чрез MeasureSpec.getMode(). След извикване на setMeasuredDimension, състоянието става част от измерените размери на View и може да бъде проверено чрез getMeasuredState(). Това се използва в ScrollView и други контейнери за превъртане за коректно предаване на ограничения на децата.

Пример за предефиниране на onMeasure в Kotlin

Нека разгледаме практически пример за създаване на персонализиран View с предефиниране на onMeasure за квадратно показване. Класът SquareView наследява View и гарантира, че ширината и височината винаги са равни, независимо от предадените MeasureSpec. В onMeasure се определя по-малката страна и се задава квадратен размер.

class SquareView(context: Context)
    : View(context) {

    override fun onMeasure(widthMeasureSpec: Int,
                       heightMeasureSpec: Int) {
        val widthSize =
            MeasureSpec.getSize(widthMeasureSpec)
        val heightSize =
            MeasureSpec.getSize(heightMeasureSpec)
        val size = minOf(widthSize, heightSize)
        setMeasuredDimension(size, size)
    }
}

Персонализирана ViewGroup с измерване на дъщерни елементи

ViewGroup изисква по-сложна логика в onMeasure, тъй като първо се измерват дъщерните елементи, след което се определя размерът на самата ViewGroup. Примерът CascadeLayout разпределя дъщерните елементи каскадно с разстояние. След измерване на всички дъщерни елементи чрез measureChildWithMargins се изчисляват общата ширина и височина.

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

    private val cascadeOffset = 40

    override fun onMeasure(widthMeasureSpec: Int,
                       heightMeasureSpec: Int) {
        var maxWidth = 0
        var totalHeight = 0
        for (i in 0 until childCount) {
            val child = getChildAt(i)
            measureChildWithMargins(child,
                widthMeasureSpec,
                cascadeOffset * i,
                heightMeasureSpec, 0)
            maxWidth = maxOf(maxWidth,
                child.measuredWidth +
                cascadeOffset * i)
            totalHeight += child.measuredHeight
        }
        setMeasuredDimension(
            resolveSize(maxWidth, widthMeasureSpec),
            resolveSize(totalHeight, heightMeasureSpec))
    }

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

    override fun onLayout(changed: Boolean,
                       l: Int, t: Int,
                       r: Int, b: Int) {
        var top = t
        for (i in 0 until childCount) {
            val child = getChildAt(i)
            val left = l + cascadeOffset * i
            child.layout(left, top,
                left + child.measuredWidth,
                top + child.measuredHeight)
            top += child.measuredHeight
        }
    }
}

Типични грешки при предефиниране на onMeasure

Пропускане на извикването на setMeasuredDimension — най-честата грешка. Ако разработчикът е предефинирал onMeasure, но не е извикал setMeasuredDimension, приложението ще се срине с IllegalStateException. Това се случва особено често, когато в метода има условни разклонения и в едно от разклоненията извикването липсва. Всеки клон на код в onMeasure трябва да завършва с извикване на setMeasuredDimension.

Игнориране на режима AT_MOST — втората по честота грешка. Ако View в режим AT_MOST винаги използва предадения размер вместо изчисление на базата на съдържанието, родителският контейнер няма да може правилно да разпредели пространството. Например TextView в AT_MOST трябва да изчисли ширината на текста и да използва минимума от желаната и предадената ширина. Игнорирането на AT_MOST води до това, че View заема цялото налично пространство дори при малко съдържание.

Създаване на обекти вътре в onMeasure — класическа грешка в производителността. Тъй като onMeasure може да бъде извикван многократно (при всяка заявка за layout), създаването на обекти (Paint, Rect, String) вътре в този метод замърсява паметта и провокира събиране на отпадъци. Всички обекти трябва да се създават веднъж в конструктора на View, а в onMeasure трябва да се изпълнява само логиката за изчисляване на размерите. Същото правило важи за onDraw и onLayout.

Измерване на дъщерни View в ViewGroup

measureChildWithMargins — е защитен метод на ViewGroup, който измерва едно дъщерно View, като взема предвид неговите MarginLayoutParams. Методът приема MeasureSpec на родителя и натрупаните отмествания по ширина и височина. Автоматично коригира MeasureSpec за дъщерното View, като изважда padding-ите на родителя и margin-а на детето, и предава коригирания MeasureSpec на child.measure().

За напреднала логика на измерване ViewGroup може да предефинира measureChild(View child, int parentWidthSpec, int parentHeightSpec) или да работи директно с MeasureSpec за всеки дъщерен елемент. Например LinearLayout в onMeasure обхожда всички дъщерни View, измерва всяко, като взема предвид неговото layout_weight, и разпределя оставащото пространство пропорционално. Този подход позволява имплементиране на произволни алгоритми за оформление.

Кеширането на резултатите от измерването чрез механизма на кеш за измерване (measure cache) е достъпно чрез флага setMeasureWithLargestChildEnabled в определени ViewGroup. В повечето случаи обаче onMeasure се извиква отново при всяка промяна на layout и кеширането не се прилага. В персонализирани ViewGroup се препоръчва минимизиране на изчисленията в onMeasure, а не разчитане на кеш.