Classic summary of Handler in Android development

When the application starts, Android first opens a main thread (that is, the UI thread), and the main thread is the UI control in the admin interface for event distribution.

AD:

First, the definition of handler:

Mainly accepts the data sent by the child thread, and updates the UI with this data in conjunction with the main thread.

Explanation: When the application starts, Android first opens a main thread (that is, the UI thread), the main thread is the UI control in the management interface for event distribution, for example, if you click on a button, Android will distribute the event to the button to respond to your action.  If you need a time-consuming operation at this time, for example: network read data, or read a large local file, you can not put these operations in the main thread, if you put in the main thread, the interface will appear suspended animation, if 5 seconds has not been completed, you will receive an Android system error message  Force Close. This time we need to put these time-consuming operations on a sub-thread, because the child threads involve UI updates, the Android main thread is not secure, that is, the update UI can only be updated in the main thread, and the operations in the child threads are dangerous. By this time, Handler appeared. To solve this complex problem, because handler is running in the mainline approached (UI thread), it and the child thread can pass the data through the Message object, at this time, the handler undertakes to accept the child thread passed over (the child thread uses the Sedmessage () method to pass the younger brother) The Message object, which contains data, is placed in the main thread queue and updated with the main thread.

Ii. Some features of handler

Handler can distribute the Message object and the Runnable object into the main thread, each handler instance is bound to create his line approached (typically in the main thread), and it has two functions:

(1) Arranging messages or runnable to be executed somewhere in a main thread;

(2) Schedule an action to be executed in a different thread.

Some ways to distribute messages in handler

Post (Runnable)

Postattime (Runnable,long)

Postdelayed (Runnable Long)

Sendemptymessage (int)

SendMessage (Message)

Sendmessageattime (Message,long)

Sendmessagedelayed (Message,long)

The Post class method above allows you to arrange a runnable object into the main thread queue,

The SendMessage class method allows you to schedule a message object with data to queue and wait for updates.

Iii. examples of Handler

Subclasses need to inherit the Hendler class and override the Handlemessage (Message msg) method to accept thread data.

The following is an instance that implements the function of modifying the contents of the interface button through a thread

2. Public class Myhandleractivity extends Activity {
4. Button button;
6. MyHandler MyHandler;
10. protected void OnCreate (Bundle savedinstancestate) {
12. Super. OnCreate (savedinstancestate);
14. Setcontentview (R. Layout Handlertest);
18. Button = (button) Findviewbyid (R. Id. button);
20. MyHandler = new MyHandler ();
22. //When a new handler instance is created, it is bound to the current thread and message queue to begin distributing data
24. //Handler has two functions, (1): Timed execution of message and Runnalbe object
26. //(2): Let an action be executed in a different thread.
30. //It arranges messages, using the following methods
32. //Post (Runnable)
34. //Postattime (Runnable,long)
36. //postdelayed (Runnable,long)
38. //sendemptymessage (int)
40. //SendMessage (Message);
42. //Sendmessageattime (Message,long)
44. //sendmessagedelayed (Message,long)
48. //The above method starts with post allowing you to process the Runnable object
50. //sendmessage () allows you to process a Message object (the message can contain data)
54. MyThread m = new MyThread ();
56. new Thread (m). Start ();
58. }
62. /** 
64. * Accept messages, process messages, and this handler will run with the current main thread
66. * */
70. class MyHandler extends Handler {
72. Public MyHandler () {
74. }
78. Public MyHandler (Looper L) {
80. super (L);
82. }
86. //Subclasses must override this method to accept data
88. @Override
90. public void Handlemessage (Message msg) {
92. //TODO auto-generated method stub
94. Log. D ("MyHandler", "Handlemessage ... "); 
96. Super. Handlemessage (msg);
98. //The UI can be updated here
100. Bundle B = Msg. GetData ();
102. String color = b. GetString ("color");
104. Myhandleractivity. This . button Append (color);
108. }
110. }
114. class MyThread implements Runnable {
116. public Void Run () {
120. try {
122. Thread. Sleep (10000);
124. } catch (Interruptedexception e) {
126. //TODO auto-generated catch block
128. E. Printstacktrace ();
130. }
134. Log. D ("thread .....") ", " Mthread ... "); 
136. Message msg = new Message ();
138. Bundle B = new bundle (); Storing Data
140. B. Putstring ("Color", "my");
142. Msg SetData (b);
146. Myhandleractivity. This . MyHandler. SendMessage (msg); //Send messages to handler, update UI
150. }
152. }
154. }

Classic summary of Handler in Android development