invalidate() — co to jest, mechanizm przerysowania i invalidate(Rect)

Czym jest invalidate() w Androidzie

invalidate() — to metoda klasy android.view.View, która informuje system Android, że wizualna reprezentacja widoku jest nieaktualna. Po wywołaniu metody system oznacza widok jako dirty i planuje jego przerysowanie w najbliższym cyklu odświeżania ekranu (zwykle 16 ms dla 60 FPS).

Metoda invalidate() przyjmuje różne formy: bez parametrów (pełne przerysowanie), z parametrem Rect (częściowe) oraz z parametrami ltrb (left, top, right, bottom). Wszystkie wersje działają asynchronicznie i mogą być wywoływane z wątku UI. Do wywołania z wątków tła istnieje postInvalidate().

Jak działa przerysowanie przez invalidate()

Mechanizm przerysowania w Androidzie opiera się na ViewRootImpl — wewnętrznym komponencie, który łączy View Hierarchy z Surface do rysowania. Gdy wywoływane jest invalidate(), ViewRootImpl oznacza obszar widoku jako dirty i wysyła żądanie przerysowania przez Choreographer — usługę systemową synchronizującą rysowanie z częstotliwością odświeżania ekranu.

Cykl przerysowania

Choreographer otrzymuje sygnał od Vsync i uruchamia potrójny przebieg: measure, layout, draw. Jednak invalidate() dotyczy tylko fazy draw — fazy measure i layout nie są wykonywane, jeśli nie został wywołany requestLayout(). To kluczowa różnica: invalidate() jest tańsze niż requestLayout(), ponieważ nie przelicza geometrii.

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() // Żądanie przerysowania
    }

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

        // Rysowanie linii wykresu
        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)
    }
}

W tym przykładzie niestandardowy View do rysowania wykresu wywołuje invalidate() przy aktualizacji danych. System przerysowuje tylko ten View, nie wpływając na pozostałe elementy hierarchii. onDraw() otrzymuje Canvas do rysowania linii przez Path.

invalidate() vs postInvalidate()

Główna różnica między invalidate() a postInvalidate() polega na bezpieczeństwie wątkowym. invalidate() może być wywoływane tylko z wątku UI (main thread). postInvalidate() można wywoływać z dowolnego wątku — przez Handler wysyła on żądanie przerysowania do wątku UI.

W praktyce postInvalidate() jest używane w scenariuszach ładowania danych z sieci, przetwarzania wyników czujników lub obliczeń w tle. Jeśli znajdujesz się w wątku UI — zawsze używaj invalidate() dla minimalnego opóźnienia.

    // Wywołane z wątku UI
view.invalidate()

    // Wywołane z wątku tła
Thread {
    // Ciężkie obliczenia
    val result = performHeavyCalculation()
    runOnUiThread {
        updateUi(result)
    }
}.start()

Częściowe przerysowanie przez invalidate(Rect)

invalidate(Rect) i invalidate(int l, int t, int r, int b) pozwalają ograniczyć obszar przerysowania. Jest to krytyczne dla wydajności: przy aktualizacji tylko części View (np. ruch kursora, zmiana wskaźnika) nie ma sensu przerysowywać całego widoku.

System przekazuje określony prostokąt dirty do onDraw() przez canvas.clipBounds. Wewnątrz onDraw() można sprawdzić clipBounds i rysować tylko w obrębie tego obszaru, chociaż Android Canvas automatycznie przycina rysowanie poza prostokątem dirty.

    // Aktualizacja częściowa: tylko obszar kursora
private val cursorRect = Rect()

fun moveCursorTo(newX: Int, newY: Int) {
    // Unieważnij starą pozycję
    invalidate(cursorRect)

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

    // Unieważnij nową pozycję
    invalidate(cursorRect)
}

Bez częściowego przerysowania każdy ruch kursora przerysowywałby cały View, co dla dużego wykresu oznacza przerysowanie tysięcy pikseli zamiast kilkudziesięciu. invalidate(Rect) — obowiązkowa technika dla edytorów, canvasów rysowania i animowanych komponentów.

invalidate() vs requestLayout(): jaka jest różnica

Jednym z częstych błędów jest wywołanie requestLayout() tam, gdzie wystarczy invalidate(), i odwrotnie. Różnica jest fundamentalna: invalidate() dotyczy tylko fazy draw, a requestLayout() uruchamia pełny cykl measure → layout → draw.

Jeśli zmieniasz tekst w TextView — wystarczy invalidate(), ponieważ rozmiar widoku się nie zmienia. Jeśli tekst może przejść do nowej linii i zwiększyć wysokość — potrzebny jest requestLayout(). Android Lint pomaga śledzić takie błędy poprzez reguły wydajności.

Optymalizacja wydajności invalidate()

Nadmierne wywołania invalidate() — jedna z głównych przyczyn niskiej wydajności niestandardowych View w Androidzie. Rozważmy techniki optymalizacji.

Minimalizuj częstotliwość wywołań

Jeśli dane aktualizują się z wysoką częstotliwością (czujniki, animacja, wideo), nie wywołuj invalidate() przy każdej zmianie. Używaj ValueAnimator lub Choreographer.FrameCallback do synchronizacji z częstotliwością odświeżania ekranu. Gwarantuje to, że invalidate() jest wywoływane nie częściej niż raz na klatkę.

Używaj Hardware Acceleration

Od API 14 Android obsługuje przyspieszenie sprzętowe przez GPU. Jeśli Twój niestandardowy View używa tylko Canvas API (drawRect, drawCircle, drawPath), przyspieszenie działa przezroczysto. Dla operacji zgodnych z DisplayList, invalidate() jest przetwarzane znacznie szybciej.

// Używanie Choreographer do synchronizacji Vsync
private val frameCallback = Choreographer.FrameCallback { frameTimeNanos ->
    updateAnimation(frameTimeNanos)
    invalidate()
    Choreographer.getInstance().postFrameCallback(this)
}

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

Używaj invalidate(Rect) do punktowych aktualizacji, unikaj wywoływania invalidate() z onDraw() (nieskończona pętla) i zawsze profiluj przez GPU Profile Rendering na urządzeniu. Pokaże to dokładny czas rysowania każdej klatki i pomoże zidentyfikować problematyczne miejsca.