invalidate() — τι είναι, μηχανισμός επανασχεδίασης και invalidate(Rect)

Τι είναι το invalidate() στο Android

invalidate() — είναι μια μέθοδος της κλάσης android.view.View που ενημερώνει το σύστημα Android ότι η οπτική αναπαράσταση της προβολής είναι ξεπερασμένη. Μετά την κλήση της μεθόδου, το σύστημα σηματοδοτεί την προβολή ως dirty και προγραμματίζει την επανασχεδίασή της στον πλησιέστερο κύκλο ανανέωσης οθόνης (συνήθως 16 ms για 60 FPS).

Η μέθοδος invalidate() παίρνει διάφορες μορφές: χωρίς παραμέτρους (πλήρης επανασχεδίαση), με παράμετρο Rect (μερική) και με παραμέτρους ltrb (left, top, right, bottom). Όλες οι εκδόσεις λειτουργούν ασύγχρονα και μπορούν να κληθούν από το νήμα UI. Για κλήση από νήματα παρασκηνίου υπάρχει το postInvalidate().

Πώς λειτουργεί η επανασχεδίαση μέσω invalidate()

Ο μηχανισμός επανασχεδίασης στο Android βασίζεται στο ViewRootImpl — ένα εσωτερικό στοιχείο που συνδέει την View Hierarchy με το Surface για σχεδίαση. Όταν καλείται το invalidate(), το ViewRootImpl σηματοδοτεί την περιοχή της προβολής ως dirty και στέλνει αίτημα επανασχεδίασης μέσω του Choreographer — μιας υπηρεσίας συστήματος που συγχρονίζει τη σχεδίαση με τη συχνότητα ανανέωσης οθόνης.

Κύκλος επανασχεδίασης

Ο Choreographer λαμβάνει σήμα από το Vsync και εκκινεί ένα τριπλό πέρασμα: measure, layout, draw. Ωστόσο, το invalidate() επηρεάζει μόνο τη φάση draw — οι φάσεις measure και layout δεν εκτελούνται εκτός αν έχει κληθεί το requestLayout(). Αυτή είναι η βασική διαφορά: το invalidate() είναι φθηνότερο από το requestLayout() επειδή δεν επανυπολογίζει τη γεωμετρία.

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() // Αίτημα επανασχεδίασης
    }

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

        // Σχεδίαση γραμμής γραφήματος
        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)
    }
}

Σε αυτό το παράδειγμα, ένα προσαρμοσμένο View για σχεδίαση γραφήματος καλεί invalidate() κατά την ενημέρωση δεδομένων. Το σύστημα επανασχεδιάζει μόνο αυτό το View, χωρίς να επηρεάζει τα υπόλοιπα στοιχεία της ιεραρχίας. Το onDraw() λαμβάνει Canvas για σχεδίαση γραμμών μέσω Path.

invalidate() vs postInvalidate()

Η κύρια διαφορά μεταξύ invalidate() και postInvalidate() είναι η ασφάλεια νημάτων. Το invalidate() πρέπει να καλείται μόνο από το νήμα UI (κύριο νήμα). Το postInvalidate() μπορεί να κληθεί από οποιοδήποτε νήμα — μέσω Handler στέλνει αίτημα επανασχεδίασης στο νήμα UI.

Στην πράξη, το postInvalidate() χρησιμοποιείται σε σενάρια φόρτωσης δεδομένων από δίκτυο, επεξεργασίας αποτελεσμάτων αισθητήρων ή υπολογισμών παρασκηνίου. Εάν βρίσκεστε στο νήμα UI — χρησιμοποιείτε πάντα invalidate() για ελάχιστη καθυστέρηση.

    // Κλήθηκε από νήμα UI
view.invalidate()

    // Κλήθηκε από νήμα παρασκηνίου
Thread {
    // Βαριοί υπολογισμοί
    val result = performHeavyCalculation()
    runOnUiThread {
        updateUi(result)
    }
}.start()

Μερική επανασχεδίαση μέσω invalidate(Rect)

invalidate(Rect) και invalidate(int l, int t, int r, int b) επιτρέπουν τον περιορισμό της περιοχής επανασχεδίασης. Αυτό είναι κρίσιμο για την απόδοση: κατά την ενημέρωση μόνο ενός μέρους του View (π.χ. κίνηση δρομέα, αλλαγή δείκτη) δεν έχει νόημα να επανασχεδιαστεί ολόκληρη η προβολή.

Το σύστημα μεταβιβάζει το καθορισμένο dirty ορθογώνιο στο onDraw() μέσω canvas.clipBounds. Μέσα στο onDraw() μπορεί να ελεγχθεί το clipBounds και να σχεδιαστεί μόνο εντός αυτής της περιοχής, αν και το Android Canvas αυτόματα αποκόπτει τη σχεδίαση εκτός του dirty ορθογωνίου.

    // Μερική ενημέρωση: μόνο περιοχή δρομέα
private val cursorRect = Rect()

fun moveCursorTo(newX: Int, newY: Int) {
    // Ακύρωση παλιάς θέσης
    invalidate(cursorRect)

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

    // Ακύρωση νέας θέσης
    invalidate(cursorRect)
}

Χωρίς μερική επανασχεδίαση, κάθε κίνηση του δρομέα θα επανασχεδίαζε ολόκληρο το View, που για ένα μεγάλο γράφημα σημαίνει επανασχεδίαση χιλιάδων pixel αντί για μερικές δεκάδες. invalidate(Rect) — υποχρεωτική τεχνική για επεξεργαστές, καμβάδες σχεδίασης και κινούμενα στοιχεία.

invalidate() vs requestLayout(): ποια η διαφορά

Ένα από τα συνηθισμένα λάθη είναι η κλήση requestLayout() εκεί που αρκεί το invalidate(), και αντίστροφα. Η διαφορά είναι θεμελιώδης: το invalidate() επηρεάζει μόνο τη φάση draw, ενώ το requestLayout() εκκινεί τον πλήρη κύκλο measure → layout → draw.

Εάν αλλάζετε κείμενο στο TextView — αρκεί το invalidate(), καθώς το μέγεθος της προβολής δεν αλλάζει. Εάν το κείμενο μπορεί να μεταφερθεί σε νέα γραμμή και να αυξήσει το ύψος — χρειάζεται requestLayout(). Το Android Lint βοηθά στην παρακολούθηση τέτοιων λαθών μέσω κανόνων απόδοσης.

Βελτιστοποίηση απόδοσης invalidate()

Οι υπερβολικές κλήσεις invalidate() — μία από τις κύριες αιτίες χαμηλής απόδοσης προσαρμοσμένων View στο Android. Ας εξετάσουμε τεχνικές βελτιστοποίησης.

Ελαχιστοποιήστε τη συχνότητα κλήσεων

Εάν τα δεδομένα ενημερώνονται με υψηλή συχνότητα (αισθητήρες, κινούμενα σχέδια, βίντεο), μην καλείτε invalidate() σε κάθε αλλαγή. Χρησιμοποιήστε ValueAnimator ή Choreographer.FrameCallback για συγχρονισμό με τη συχνότητα ανανέωσης οθόνης. Αυτό εγγυάται ότι το invalidate() καλείται όχι περισσότερο από μία φορά ανά καρέ.

Χρησιμοποιήστε Hardware Acceleration

Από το API 14, το Android υποστηρίζει επιτάχυνση υλικού μέσω GPU. Εάν το προσαρμοσμένο View σας χρησιμοποιεί μόνο Canvas API (drawRect, drawCircle, drawPath), η επιτάχυνση λειτουργεί διαφανώς. Για λειτουργίες συμβατές με DisplayList, το invalidate() επεξεργάζεται σημαντικά ταχύτερα.

// Χρήση Choreographer για συγχρονισμό Vsync
private val frameCallback = Choreographer.FrameCallback { frameTimeNanos ->
    updateAnimation(frameTimeNanos)
    invalidate()
    Choreographer.getInstance().postFrameCallback(this)
}

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

Χρησιμοποιήστε invalidate(Rect) για σημειακές ενημερώσεις, αποφύγετε την κλήση invalidate() από το onDraw() (ατέρμονος βρόχος) και κάνετε πάντα προφίλ μέσω GPU Profile Rendering στη συσκευή. Αυτό θα δείξει τον ακριβή χρόνο σχεδίασης κάθε καρέ και θα βοηθήσει στον εντοπισμό προβληματικών σημείων.