android - When it's necessary to execute invalidate() on a View?

Question

My answer to this question was just accepted but I started to wonder when exactly one needs to invalidate() a View and when it is not necessary?

After a bit of thinking I came to realization that it should work more or less like this:

• actual drawing of "everything" occurs after onResume()
• in "free" time parts of the screen can be redrawn but only those that were invalidated (and everything underneath)

Therefore, it would seem, if I change something after onResume() (e.g. as a response to a button click, I should invalidate() the changed View).

However, from what scana in this question says, it must be more complex then that and it depends somethimes on what method one uses.

E.g. on whether one uses

lastClicked.setImageBitmap();

or

lastClicked.setImageResource();

So, when it's necessary to execute invalidate() on a View and how does it really work ?

Answer 1

(Do consider accepting some answers)

Generally, invalidate() means 'redraw on screen' and results to a call of the view's onDraw() method. So if something changes and it needs to be reflected on screen, you need to call invalidate(). However, for built-in widgets you rarely, if ever, need to call it yourself. When you change the state of a widget, internal code will call invalidate() as necessary and your change will be reflected on screen. For example, if you call TextView.setText(), after doing a lot of internal processing (will the text fit on screen, does it need to be ellipsised, etc.), TextView will call invalidate() before setText() returns. Similarly for other widgets.

If you implement a custom view, you will need to call invalidate() whenever the backing model changes and you need to redraw your view. It can also be used to create simple animations, where you change state, then call invalidate(), change state again, etc.