invalidate() — ano ito, mekanismo ng muling pagguhit at invalidate(Rect)

Ano ang invalidate() sa Android

invalidate() — ay isang pamamaraan ng klase ng android.view.View na nagpapaalam sa Android system na ang visual na representasyon ng view ay luma na. Pagkatapos ng pagtawag sa pamamaraan, minamarkahan ng sistema ang view bilang dirty at nag-iiskedyul ng muling pagguhit nito sa pinakamalapit na cycle ng pag-update ng screen (karaniwang 16 ms para sa 60 FPS).

Ang pamamaraang invalidate() ay tumatanggap ng iba't ibang anyo: walang parameter (buong muling pagguhit), may parameter na Rect (bahagyang) at may mga parameter na ltrb (left, top, right, bottom). Lahat ng bersyon ay gumagana nang asynchronous at maaaring tawagin mula sa UI thread. Para sa pagtawag mula sa mga background thread ay mayroong postInvalidate().

Paano gumagana ang muling pagguhit sa pamamagitan ng invalidate()

Ang mekanismo ng muling pagguhit sa Android ay batay sa ViewRootImpl — isang panloob na bahagi na nag-uugnay ng View Hierarchy sa Surface para sa pagguhit. Kapag tinawag ang invalidate(), minamarkahan ng ViewRootImpl ang lugar ng view bilang dirty at nagpapadala ng kahilingan sa muling pagguhit sa pamamagitan ng Choreographer — isang serbisyo ng sistema na nag-si-synchronize ng pagguhit sa dalas ng pag-update ng screen.

Cycle ng muling pagguhit

Ang Choreographer ay tumatanggap ng signal mula sa Vsync at naglulunsad ng triple pass: measure, layout, draw. Gayunpaman, ang invalidate() ay nakakaapekto lamang sa draw phase — ang measure at layout phase ay hindi isinasagawa maliban kung tinawag ang requestLayout(). Ito ang pangunahing pagkakaiba: ang invalidate() ay mas magaan kaysa sa requestLayout() dahil hindi nito kinukwenta muli ang geometry.

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() // Kahilingan sa muling pagguhit
    }

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

        // Pagguhit ng linya ng graph
        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)
    }
}

Sa halimbawang ito, ang isang custom na View para sa pagguhit ng graph ay tumatawag ng invalidate() kapag nag-a-update ng data. Ang sistema ay muling gumuhit lamang ng View na ito, nang hindi naaapektuhan ang iba pang mga elemento ng hierarchy. onDraw() ay tumatanggap ng Canvas para sa pagguhit ng mga linya sa pamamagitan ng Path.

invalidate() vs postInvalidate()

Ang pangunahing pagkakaiba sa pagitan ng invalidate() at postInvalidate() ay ang kaligtasan sa thread. invalidate() ay dapat lamang tawagin mula sa UI thread (pangunahing thread). postInvalidate() ay maaaring tawagin mula sa anumang thread — sa pamamagitan ng Handler nagpapadala ito ng kahilingan sa muling pagguhit sa UI thread.

Sa praktika, ang postInvalidate() ay ginagamit sa mga senaryo ng pag-load ng data mula sa network, pagproseso ng mga resulta ng sensor o mga background computation. Kung ikaw ay nasa UI thread — palaging gamitin ang invalidate() para sa minimal na latency.

    // Tinawag mula sa UI thread
view.invalidate()

    // Tinawag mula sa background thread
Thread {
    // Mabibigat na kalkulasyon
    val result = performHeavyCalculation()
    runOnUiThread {
        updateUi(result)
    }
}.start()

Bahagyang muling pagguhit sa pamamagitan ng invalidate(Rect)

invalidate(Rect) at invalidate(int l, int t, int r, int b) ay nagbibigay-daan sa paglilimita sa lugar ng muling pagguhit. Ito ay kritikal para sa pagganap: kapag nag-a-update lamang ng bahagi ng View (halimbawa, paggalaw ng cursor, pagbabago ng indicator) walang saysay na muling iguhit ang buong view.

Ipinapasa ng sistema ang tinukoy na dirty rectangle sa onDraw() sa pamamagitan ng canvas.clipBounds. Sa loob ng onDraw() ay maaaring suriin ang clipBounds at gumuhit lamang sa loob ng lugar na ito, bagaman ang Android Canvas ay awtomatikong pinuputol ang pagguhit sa labas ng dirty rectangle.

    // Bahagyang pag-update: lugar ng cursor lamang
private val cursorRect = Rect()

fun moveCursorTo(newX: Int, newY: Int) {
    // Invalidate lumang posisyon
    invalidate(cursorRect)

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

    // Invalidate bagong posisyon
    invalidate(cursorRect)
}

Kung walang bahagyang muling pagguhit, bawat paggalaw ng cursor ay muling iguguhit ang buong View, na para sa isang malaking graph ay nangangahulugan ng muling pagguhit ng libu-libong pixel sa halip na ilang dosena. invalidate(Rect) — isang sapilitang pamamaraan para sa mga editor, canvas ng pagguhit at mga animated na bahagi.

invalidate() vs requestLayout(): ano ang pagkakaiba

Ang isa sa mga karaniwang pagkakamali ay ang pagtawag ng requestLayout() kung saan sapat na ang invalidate(), at kabaliktaran. Ang pagkakaiba ay pundamental: invalidate() ay nakakaapekto lamang sa draw phase, habang ang requestLayout() ay naglulunsad ng buong measure → layout → draw cycle.

Kung magbabago ng teksto sa TextView — sapat na ang invalidate(), dahil hindi nagbabago ang laki ng view. Kung ang teksto ay maaaring lumipat sa bagong linya at dagdagan ang taas — kailangan ang requestLayout(). Android Lint ay tumutulong subaybayan ang mga ganitong pagkakamali sa pamamagitan ng mga patakaran sa pagganap.

Pag-optimize ng pagganap ng invalidate()

Ang labis na mga tawag sa invalidate() — isa sa mga pangunahing dahilan ng mababang pagganap ng mga custom na View sa Android. Tingnan natin ang mga pamamaraan ng pag-optimize.

I-minimize ang dalas ng pagtawag

Kung ang data ay nag-a-update na may mataas na dalas (mga sensor, animation, video), huwag tawagin ang invalidate() sa bawat pagbabago. Gamitin ang ValueAnimator o Choreographer.FrameCallback para sa pag-sync sa dalas ng pag-update ng screen. Tinitiyak nito na ang invalidate() ay tinatawag nang hindi hihigit sa isang beses bawat frame.

Gamitin ang Hardware Acceleration

Mula sa API 14, sinusuportahan ng Android ang hardware acceleration sa pamamagitan ng GPU. Kung ang iyong custom na View ay gumagamit lamang ng Canvas API (drawRect, drawCircle, drawPath), ang acceleration ay gumagana nang transparent. Para sa mga operasyong compatible sa DisplayList, ang invalidate() ay pinoproseso nang mas mabilis.

// Paggamit ng Choreographer para sa Vsync synchronization
private val frameCallback = Choreographer.FrameCallback { frameTimeNanos ->
    updateAnimation(frameTimeNanos)
    invalidate()
    Choreographer.getInstance().postFrameCallback(this)
}

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

Gamitin ang invalidate(Rect) para sa mga point update, iwasan ang pagtawag ng invalidate() mula sa onDraw() (walang katapusang loop), at palaging mag-profile sa pamamagitan ng GPU Profile Rendering sa device. Ipapakita nito ang eksaktong oras ng pagguhit ng bawat frame at makakatulong na matukoy ang mga problematikong lugar.