invalidate() — какво е, механизъм на прерисуване и invalidate(Rect)

Какво е invalidate() в Android

invalidate() — е метод на класа android.view.View, който уведомява системата Android, че визуалното представяне на изгледа е остаряло. След извикването на метода, системата маркира изгледа като dirty и планира неговото прерисуване в най-близкия цикъл на обновяване на екрана (обикновено 16 ms за 60 FPS).

Методът invalidate() приема различни форми: без параметри (пълно прерисуване), с параметър Rect (частично) и с параметри ltrb (left, top, right, bottom). Всички версии работят асинхронно и могат да бъдат извикани от UI нишката. За извикване от фонови нишки съществува postInvalidate().

Как работи прерисуването чрез invalidate()

Механизмът на прерисуване в Android се основава на ViewRootImpl — вътрешен компонент, който свързва View Hierarchy с Surface за рисуване. Когато се извика invalidate(), ViewRootImpl маркира областта на изгледа като dirty и изпраща заявка за прерисуване чрез Choreographer — системна услуга, синхронизираща рисуването с честотата на обновяване на екрана.

Цикъл на прерисуване

Choreographer получава сигнал от Vsync и стартира троен проход: measure, layout, draw. Въпреки това, invalidate() засяга само фазата draw — фазите measure и layout не се изпълняват, освен ако не е извикан requestLayout(). Това е ключовата разлика: invalidate() е по-евтин от requestLayout(), защото не преизчислява геометрията.

class CustomChartView(context: Context, attrs: AttributeSet?)
    : View(context, attrs) {

    private var dataPoints: List<Float> = emptyList()
    private val paint = Paint(Paint.ANTI_ALIAS_FLAG)

    fun updateData(newPoints: List<Float>) {
        dataPoints = newPoints
        invalidate() // Заявка за прерисуване
    }

    override fun onDraw(canvas: Canvas) {
        super.onDraw(canvas)
        paint.color = Color.BLUE
        paint.strokeWidth = 4f
        paint.style = Paint.Style.STROKE

        // Рисуване на линия на графика
        val path = Path()
        dataPoints.forEachIndexed { index, value ->
            val x = index * width / max(dataPoints.size - 1, 1)
            val y = height - value * height
            if (index == 0) path.moveTo(x, y)
            else path.lineTo(x, y)
        }
        canvas.drawPath(path, paint)
    }
}

В този пример, потребителски View за рисуване на графика извиква invalidate() при обновяване на данни. Системата прерисува само този View, без да засяга останалите елементи на йерархията. onDraw() получава Canvas за рисуване на линии чрез Path.

invalidate() vs postInvalidate()

Основната разлика между invalidate() и postInvalidate() е в безопасността на нишките. invalidate() трябва да се извиква само от UI нишката (главната нишка). postInvalidate() може да се извика от всяка нишка — чрез Handler изпраща заявка за прерисуване до UI нишката.

На практика, postInvalidate() се използва в сценарии за зареждане на данни от мрежа, обработка на резултати от сензори или фонови изчисления. Ако сте в UI нишката — винаги използвайте invalidate() за минимална латентност.

    // Извикано от UI нишка
view.invalidate()

    // Извикано от фонова нишка
Thread {
    // Тежки изчисления
    val result = performHeavyCalculation()
    runOnUiThread {
        updateUi(result)
    }
}.start()

Частично прерисуване чрез invalidate(Rect)

invalidate(Rect) и invalidate(int l, int t, int r, int b) позволяват ограничаване на областта за прерисуване. Това е критично за производителността: при обновяване само на част от View (например движение на курсора, промяна на индикатор) няма смисъл да се прерисува целия изглед.

Системата предава указания dirty правоъгълник на onDraw() чрез canvas.clipBounds. Вътре в onDraw() може да се провери clipBounds и да се рисува само в границите на тази област, въпреки че Android Canvas автоматично изрязва рисуването извън dirty правоъгълника.

    // Частично обновяване: само област на курсора
private val cursorRect = Rect()

fun moveCursorTo(newX: Int, newY: Int) {
    // Анулиране на стара позиция
    invalidate(cursorRect)

    cursorRect.set(newX - 5, newY - 5,
                  newX + 5, newY + 5)

    // Анулиране на нова позиция
    invalidate(cursorRect)
}

Без частично прерисуване, всяко движение на курсора би прерисувало целия View, което за голяма графика означава прерисуване на хиляди пиксели вместо няколко десетки. invalidate(Rect) — задължителна техника за редактори, платна за рисуване и анимирани компоненти.

invalidate() vs requestLayout(): каква е разликата

Една от честите грешки е извикването на requestLayout() там, където е достатъчен invalidate(), и обратно. Разликата е фундаментална: invalidate() засяга само фазата draw, докато requestLayout() стартира пълния цикъл measure → layout → draw.

Ако променяте текст в TextView — достатъчен е invalidate(), тъй като размерът на изгледа не се променя. Ако текстът може да премине на нов ред и да увеличи височината — е необходим requestLayout(). Android Lint помага за проследяване на такива грешки чрез правила за производителност.

Оптимизиране на производителността на invalidate()

Прекомерните извиквания на invalidate() — една от основните причини за ниска производителност на потребителски View в Android. Нека разгледаме техники за оптимизация.

Минимизирайте честотата на извиквания

Ако данните се обновяват с висока честота (сензори, анимация, видео), не извиквайте invalidate() при всяка промяна. Използвайте ValueAnimator или Choreographer.FrameCallback за синхронизация с честотата на обновяване на екрана. Това гарантира, че invalidate() се извиква не повече от веднъж на кадър.

Използвайте Hardware Acceleration

От API 14 Android поддържа хардуерно ускорение чрез GPU. Ако вашият потребителски View използва само Canvas API (drawRect, drawCircle, drawPath), ускорението работи прозрачно. За операции, съвместими с DisplayList, invalidate() се обработва значително по-бързо.

// Използване на Choreographer за Vsync синхронизация
private val frameCallback = Choreographer.FrameCallback { frameTimeNanos ->
    updateAnimation(frameTimeNanos)
    invalidate()
    Choreographer.getInstance().postFrameCallback(this)
}

fun startAnimation() {
    Choreographer.getInstance().postFrameCallback(frameCallback)
}

Използвайте invalidate(Rect) за точкови обновявания, избягвайте извикването на invalidate() от onDraw() (безкраен цикъл) и винаги профилирайте чрез GPU Profile Rendering на устройството. Това ще покаже точното време за рисуване на всеки кадър и ще помогне за идентифициране на проблемни места.