invalidate() — wat is het, hertekeningsmechanisme en invalidate(Rect)

Wat is invalidate() in Android

invalidate() — is een methode van de klasse android.view.View die het Android-systeem informeert dat de visuele weergave van de view verouderd is. Na het aanroepen van de methode markeert het systeem de view als dirty en plant het hertekenen ervan in de dichtstbijzijnde schermverversingscyclus (meestal 16 ms voor 60 FPS).

De methode invalidate() neemt verschillende vormen aan: zonder parameters (volledige hertekening), met de parameter Rect (gedeeltelijk) en met de parameters ltrb (left, top, right, bottom). Alle versies werken asynchroon en kunnen vanuit de UI-thread worden aangeroepen. Voor aanroep vanuit achtergrondthreads bestaat postInvalidate().

Hoe werkt hertekening via invalidate()

Het hertekeningsmechanisme in Android is gebaseerd op ViewRootImpl — een interne component die View Hierarchy verbindt met Surface voor het tekenen. Wanneer invalidate() wordt aangeroepen, markeert ViewRootImpl het gebied van de view als dirty en stuurt een verzoek tot hertekening via Choreographer — een systeemservice die het tekenen synchroniseert met de schermverversingsfrequentie.

Hertekeningscyclus

Choreographer ontvangt het signaal van Vsync en start een drievoudige doorgang: measure, layout, draw. Echter, invalidate() heeft alleen invloed op de draw-fase — de measure- en layout-fasen worden niet uitgevoerd tenzij requestLayout() is aangeroepen. Dit is het belangrijkste verschil: invalidate() is goedkoper dan requestLayout() omdat het de geometrie niet herberekent.

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() // Hertekeningsverzoek
    }

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

        // Grafieklijn tekenen
        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)
    }
}

In dit voorbeeld roept een aangepaste View voor het tekenen van een grafiek invalidate() aan bij het bijwerken van gegevens. Het systeem hertekent alleen deze View, zonder de overige elementen van de hiërarchie te beïnvloeden. onDraw() ontvangt Canvas voor het tekenen van lijnen via Path.

invalidate() vs postInvalidate()

Het belangrijkste verschil tussen invalidate() en postInvalidate() is de threadveiligheid. invalidate() mag alleen vanuit de UI-thread (hoofdthread) worden aangeroepen. postInvalidate() kan vanuit elke thread worden aangeroepen — via Handler stuurt het een hertekeningsverzoek naar de UI-thread.

In de praktijk wordt postInvalidate() gebruikt in scenario's van het laden van gegevens uit netwerk, verwerking van sensorresultaten of achtergrondberekeningen. Als u zich in de UI-thread bevindt — gebruik dan altijd invalidate() voor minimale latentie.

    // Aangeroepen vanuit UI-thread
view.invalidate()

    // Aangeroepen vanuit achtergrondthread
Thread {
    // Zware berekeningen
    val result = performHeavyCalculation()
    runOnUiThread {
        updateUi(result)
    }
}.start()

Gedeeltelijke hertekening via invalidate(Rect)

invalidate(Rect) en invalidate(int l, int t, int r, int b) maken het mogelijk het hertekeningsgebied te beperken. Dit is cruciaal voor prestaties: bij het bijwerken van slechts een deel van View (bijvoorbeeld cursorverplaatsing, indicatorwijziging) heeft het geen zin om de hele view te hertekenen.

Het systeem geeft de opgegeven dirty-rechthoek door aan onDraw() via canvas.clipBounds. Binnen onDraw() kan clipBounds worden gecontroleerd en alleen binnen dit gebied worden getekend, hoewel Android Canvas automatisch het tekenen buiten de dirty-rechthoek begrenst.

    // Gedeeltelijke update: alleen cursorgebied
private val cursorRect = Rect()

fun moveCursorTo(newX: Int, newY: Int) {
    // Oude positie ongeldig maken
    invalidate(cursorRect)

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

    // Nieuwe positie ongeldig maken
    invalidate(cursorRect)
}

Zonder gedeeltelijke hertekening zou elke cursorverplaatsing de hele View hertekenen, wat voor een grote grafiek betekent dat duizenden pixels worden hertekend in plaats van enkele tientallen. invalidate(Rect) — een verplichte techniek voor editors, teken canvassen en geanimeerde componenten.

invalidate() vs requestLayout(): wat is het verschil

Een veelgemaakte fout is het aanroepen van requestLayout() waar invalidate() voldoende is, en omgekeerd. Het verschil is fundamenteel: invalidate() heeft alleen invloed op de draw-fase, terwijl requestLayout() de volledige measure → layout → draw-cyclus start.

Als u tekst in TextView wijzigt — is invalidate() voldoende, omdat de grootte van de view niet verandert. Als de tekst naar een nieuwe regel kan gaan en de hoogte kan vergroten — is requestLayout() nodig. Android Lint helpt dergelijke fouten te volgen via prestatieregels.

Prestatieoptimalisatie van invalidate()

Overmatige invalidate()-aanroepen — een van de belangrijkste oorzaken van lage prestaties van aangepaste Views in Android. Laten we optimalisatietechnieken bekijken.

Minimaliseer de aanroepfrequentie

Als gegevens met hoge frequentie worden bijgewerkt (sensoren, animatie, video), roep dan niet invalidate() aan bij elke wijziging. Gebruik ValueAnimator of Choreographer.FrameCallback voor synchronisatie met de schermverversingsfrequentie. Dit garandeert dat invalidate() niet vaker dan één keer per frame wordt aangeroepen.

Gebruik Hardware Acceleration

Vanaf API 14 ondersteunt Android hardwareversnelling via GPU. Als uw aangepaste View alleen Canvas API (drawRect, drawCircle, drawPath) gebruikt, werkt de versnelling transparant. Voor DisplayList-compatibele bewerkingen wordt invalidate() aanzienlijk sneller verwerkt.

// Choreographer gebruiken voor Vsync-synchronisatie
private val frameCallback = Choreographer.FrameCallback { frameTimeNanos ->
    updateAnimation(frameTimeNanos)
    invalidate()
    Choreographer.getInstance().postFrameCallback(this)
}

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

Gebruik invalidate(Rect) voor puntige updates, vermijd het aanroepen van invalidate() vanuit onDraw() (oneindige lus) en profileer altijd via GPU Profile Rendering op het apparaat. Dit toont de exacte tekentijd van elk frame en helpt problematische plekken te identificeren.