invalidate() — Nó là gì, cơ chế vẽ lại và invalidate(Rect)

invalidate() trong Android là gì

invalidate() là một phương thức của lớp android.view.View, thông báo cho hệ thống Android rằng biểu diễn trực quan của một view đã lỗi thời. Sau khi gọi phương thức, hệ thống đánh dấu view là dirty và lên lịch vẽ lại trong chu kỳ làm mới màn hình tiếp theo (thường là 16 ms cho 60 FPS).

Phương thức invalidate() có nhiều dạng: không tham số (vẽ lại toàn bộ), với tham số Rect (một phần) và với tham số ltrb (left, top, right, bottom). Tất cả các phiên bản đều hoạt động không đồng bộ và phải được gọi từ luồng UI. Để gọi từ luồng nền, có postInvalidate().

Cơ chế vẽ lại qua invalidate() hoạt động như thế nào

Cơ chế vẽ lại trong Android dựa trên ViewRootImpl — một thành phần nội bộ kết nối hệ phân cấp View với Surface để vẽ. Khi invalidate() được gọi, ViewRootImpl đánh dấu khu vực view là dirty và gửi yêu cầu vẽ lại qua Choreographer — một dịch vụ hệ thống đồng bộ hóa việc vẽ với tần số làm mới màn hình.

Chu kỳ vẽ lại

Choreographer nhận tín hiệu từ Vsync và bắt đầu quy trình ba bước: measure, layout, draw. Tuy nhiên, invalidate() chỉ ảnh hưởng đến giai đoạn draw — các giai đoạn measure và layout không được thực thi trừ khi requestLayout() được gọi. Đây là điểm khác biệt chính: invalidate() nhẹ hơn requestLayout() vì nó không tính toán lại hình học.

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() // Yêu cầu vẽ lại
    }

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

        // Đang vẽ đường biểu đồ
        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)
    }
}

Trong ví dụ này, một View tùy chỉnh để vẽ biểu đồ gọi invalidate() khi dữ liệu được cập nhật. Hệ thống chỉ vẽ lại View này mà không ảnh hưởng đến các phần tử khác trong hệ phân cấp. onDraw() nhận Canvas để vẽ các đường qua Path.

invalidate() vs postInvalidate()

Sự khác biệt chính giữa invalidate() và postInvalidate() nằm ở tính an toàn luồng. invalidate() chỉ được gọi từ luồng UI (luồng chính). postInvalidate() có thể được gọi từ bất kỳ luồng nào — nó gửi yêu cầu vẽ lại đến luồng UI qua Handler.

Trong thực tế, postInvalidate() được sử dụng trong các kịch bản tải dữ liệu mạng, xử lý kết quả cảm biến hoặc tính toán nền. Nếu bạn đang ở trong luồng UI — hãy luôn sử dụng invalidate() để có độ trễ tối thiểu.

    // Được gọi từ luồng UI
view.invalidate()

    // Được gọi từ luồng nền
Thread {
    // Tính toán nặng
    val result = performHeavyCalculation()
    runOnUiThread {
        updateUi(result)
    }
}.start()

Vẽ lại một phần qua invalidate(Rect)

invalidate(Rect) và invalidate(int l, int t, int r, int b) cho phép giới hạn khu vực vẽ lại. Điều này rất quan trọng cho hiệu suất: khi chỉ một phần của View thay đổi (ví dụ: di chuyển con trỏ, thay đổi chỉ báo), không cần vẽ lại toàn bộ view.

Hệ thống truyền hình chữ nhật dirty được chỉ định đến onDraw() qua canvas.clipBounds. Bên trong onDraw(), bạn có thể kiểm tra clipBounds và chỉ vẽ trong khu vực đó, mặc dù Android Canvas tự động cắt việc vẽ bên ngoài hình chữ nhật dirty.

    // Cập nhật một phần: chỉ khu vực con trỏ
private val cursorRect = Rect()

fun moveCursorTo(newX: Int, newY: Int) {
    // Vô hiệu hóa vị trí cũ
    invalidate(cursorRect)

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

    // Vô hiệu hóa vị trí mới
    invalidate(cursorRect)
}

Nếu không có vẽ lại một phần, mỗi lần di chuyển con trỏ sẽ vẽ lại toàn bộ View, điều này đối với một biểu đồ lớn có nghĩa là vẽ lại hàng nghìn pixel thay vì vài chục. invalidate(Rect) là kỹ thuật thiết yếu cho trình chỉnh sửa, canvas vẽ và thành phần hoạt hình.

invalidate() vs requestLayout(): sự khác biệt là gì

Một lỗi phổ biến là gọi requestLayout() ở nơi chỉ cần invalidate() và ngược lại. Sự khác biệt là cơ bản: invalidate() chỉ ảnh hưởng đến giai đoạn draw, trong khi requestLayout() kích hoạt một chu kỳ đầy đủ measure → layout → draw.

Nếu bạn thay đổi văn bản trong TextView, chỉ cần invalidate() vì kích thước view không thay đổi. Nếu văn bản có thể xuống dòng mới và tăng chiều cao, cần requestLayout(). Android Lint giúp theo dõi các lỗi này qua các quy tắc hiệu suất.

Tối ưu hiệu suất invalidate()

Các lệnh gọi invalidate() quá mức là một trong những nguyên nhân chính gây hiệu suất kém cho View tùy chỉnh trong Android. Hãy xem các kỹ thuật tối ưu.

Giảm tần suất gọi

Nếu dữ liệu được cập nhật với tần suất cao (cảm biến, hoạt ảnh, video), đừng gọi invalidate() cho mỗi thay đổi. Sử dụng ValueAnimator hoặc Choreographer.FrameCallback để đồng bộ với tần số làm mới màn hình. Điều này đảm bảo invalidate() được gọi không quá một lần mỗi khung hình.

Sử dụng tăng tốc phần cứng

Từ API 14, Android hỗ trợ tăng tốc phần cứng qua GPU. Nếu View tùy chỉnh của bạn chỉ sử dụng Canvas API (drawRect, drawCircle, drawPath), tăng tốc hoạt động trong suốt. Đối với các hoạt động tương thích DisplayList, invalidate() được xử lý nhanh hơn đáng kể.

// Sử dụng Choreographer để đồng bộ Vsync
private val frameCallback = Choreographer.FrameCallback { frameTimeNanos ->
    updateAnimation(frameTimeNanos)
    invalidate()
    Choreographer.getInstance().postFrameCallback(this)
}

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

Sử dụng invalidate(Rect) cho các cập nhật mục tiêu, tránh gọi invalidate() từ onDraw() (vòng lặp vô hạn), và luôn đo lường qua GPU Profile Rendering trên thiết bị. Điều này sẽ hiển thị thời gian kết xuất chính xác của mỗi khung hình và giúp xác định các khu vực có vấn đề.