invalidate() — bu nima, qayta chizish mexanizmi va invalidate(Rect)

Android-da invalidate() nima

invalidate() — android.view.View sinfining metodi bo'lib, Android tizimiga ko'rinishning vizual tasviri eskirganligini bildiradi. Metod chaqirilgandan so'ng, tizim ko'rinishni dirty deb belgilaydi va uni ekran yangilanish siklining eng yaqin vaqtida qayta chizishni rejalashtiradi (odatda 60 FPS uchun 16 ms).

invalidate() metodi turli shakllarni qabul qiladi: parametrsiz (to'liq qayta chizish), Rect parametri bilan (qisman) va ltrb parametrlari bilan (left, top, right, bottom). Barcha versiyalar asinxron ishlaydi va UI thread-dan chaqirilishi mumkin. Fon thread-lardan chaqirish uchun postInvalidate() mavjud.

invalidate() orqali qayta chizish qanday ishlaydi

Android-da qayta chizish mexanizmi ViewRootImpl ga asoslangan — View Hierarchy-ni chizish uchun Surface bilan bog'laydigan ichki komponent. invalidate() chaqirilganda, ViewRootImpl ko'rinish hududini dirty deb belgilaydi va Choreographer — chizishni ekran yangilanish chastotasi bilan sinxronlaydigan tizim xizmati orqali qayta chizish so'rovini yuboradi.

Qayta chizish sikli

Choreographer Vsync dan signal oladi va uchlik o'tishni ishga tushiradi: measure, layout, draw. Biroq invalidate() faqat draw fazasiga ta'sir qiladi — measure va layout fazalari requestLayout() chaqirilmagan bo'lsa, bajarilmaydi. Bu asosiy farq: invalidate() requestLayout() dan yengilroq, chunki geometriyani qayta hisoblamaydi.

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() // Qayta chizish so'rovi
    }

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

        // Grafik chizig'ini chizish
        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)
    }
}

Ushbu misolda, grafik chizish uchun maxsus View ma'lumot yangilanganda invalidate() chaqiradi. Tizim faqat shu View-ni qayta chizadi, iyerarxiyaning qolgan elementlariga ta'sir qilmaydi. onDraw() Path orqali chiziqlar chizish uchun Canvas oladi.

invalidate() vs postInvalidate()

invalidate() va postInvalidate() o'rtasidagi asosiy farq thread xavfsizligidadir. invalidate() faqat UI thread-dan (main thread) chaqirilishi kerak. postInvalidate() istalgan thread-dan chaqirilishi mumkin — Handler orqali qayta chizish so'rovini UI thread-ga yuboradi.

Amalda, postInvalidate() tarmoqdan ma'lumot yuklash, sensor natijalarini qayta ishlash yoki fon hisoblash stsenariylarida ishlatiladi. UI thread-da bo'lsangiz — minimal kechikish uchun har doim invalidate() dan foydalaning.

    // UI thread-dan chaqirildi
view.invalidate()

    // Fon thread-dan chaqirildi
Thread {
    // Og'ir hisoblar
    val result = performHeavyCalculation()
    runOnUiThread {
        updateUi(result)
    }
}.start()

invalidate(Rect) orqali qisman qayta chizish

invalidate(Rect) va invalidate(int l, int t, int r, int b) qayta chizish hududini cheklash imkonini beradi. Bu ishlash uchun juda muhim: View-ning faqat bir qismi yangilanganda (masalan, kursor harakati, indikator o'zgarishi) butun ko'rinishni qayta chizishning ma'nosi yo'q.

Tizim belgilangan dirty to'rtburchakni onDraw() ga canvas.clipBounds orqali uzatadi. onDraw() ichida clipBounds tekshirilishi va faqat shu hudud chegarasida chizish mumkin, garchi Android Canvas avtomatik ravishda dirty to'rtburchakdan tashqaridagi chizishni kesib tashlaydi.

    // Qisman yangilash: faqat kursor maydoni
private val cursorRect = Rect()

fun moveCursorTo(newX: Int, newY: Int) {
    // Eski pozitsiyani bekor qilish
    invalidate(cursorRect)

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

    // Yangi pozitsiyani bekor qilish
    invalidate(cursorRect)
}

Qisman qayta chizishsiz, har bir kursor harakati butun View-ni qayta chizadi, bu katta grafik uchun bir necha o'nlab o'rniga minglab piksellarning qayta chizilishi degani. invalidate(Rect) — muharrirlar, chizish canvaslari va animatsiya qilingan komponentlar uchun majburiy texnika.

invalidate() vs requestLayout(): farq nima

Keng tarqalgan xatolardan biri requestLayout() ni invalidate() yetarli bo'lgan joyda chaqirish va aksincha. Farq asosiy: invalidate() faqat draw fazasiga ta'sir qiladi, requestLayout() esa to'liq measure → layout → draw siklini ishga tushiradi.

TextView da matnni o'zgartirsangiz — invalidate() yetarli, chunki ko'rinishning o'lchami o'zgarmaydi. Agar matn yangi qatorga o'tib balandlikni oshirishi mumkin bo'lsa — requestLayout() kerak. Android Lint ishlash qoidalari orqali bunday xatolarni kuzatishga yordam beradi.

invalidate() ishlashini optimallashtirish

Haddan tashqari invalidate() chaqiruvlari — Android-da maxsus View-larning past ishlashining asosiy sabablaridan biridir. Optimallashtirish texnikalarini ko'rib chiqaylik.

Chaqiruv chastotasini minimallashtiring

Agar ma'lumotlar yuqori chastota bilan yangilansa (datchiklar, animatsiya, video), har bir o'zgarishda invalidate() chaqirmang. Ekran yangilanish chastotasi bilan sinxronlash uchun ValueAnimator yoki Choreographer.FrameCallback dan foydalaning. Bu invalidate() har bir kadrda bir martadan ko'p chaqirilmasligini kafolatlaydi.

Hardware Acceleration dan foydalaning

API 14 dan boshlab Android GPU orqali apparat tezlashtirishni qo'llab-quvvatlaydi. Agar maxsus View faqat Canvas API (drawRect, drawCircle, drawPath) ishlatsa, tezlashtirish shaffof ishlaydi. DisplayList-ga mos operatsiyalar uchun invalidate() sezilarli darajada tezroq ishlanadi.

// Vsync sinxronlash uchun Choreographer dan foydalanish
private val frameCallback = Choreographer.FrameCallback { frameTimeNanos ->
    updateAnimation(frameTimeNanos)
    invalidate()
    Choreographer.getInstance().postFrameCallback(this)
}

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

Nuqtaviy yangilanishlar uchun invalidate(Rect) dan foydalaning, onDraw() ichidan invalidate() chaqirishdan saqlaning (cheksiz sikl) va har doim qurilmada GPU Profile Rendering orqali profil oling. Bu har bir kadrning chizilish vaqtini ko'rsatadi va muammoli joylarni aniqlashga yordam beradi.