Android messaging Mechanism (1)

In Android, messages are often used when information is interacting within or between threads, and these basic things can make it easier and better to architect the system and avoid some low-level errors if we are familiar with its internal principles. Before learning the messaging mechanism in Android, let's look at a few classes related to messages:

1.Message

A Message object, as the name implies, is the class that records message information. There are several more important fields for this class:

A.arg1 and Arg2: We can use two fields to hold the integer value we need to pass, and in the service we can store the service ID.

B.obj: This field is an object type, and we can let the field pass a number of items to the recipient of the message.

C.what: This field can be said to be a message flag, in the message processing, we can according to the different values of this field to do different processing, similar to when we handle the button event, through switch (V.getid ()) to determine which button is clicked.

When using the message, we can create a message instance from the new message (), but Android recommends that we pass Message.obtain () or handler.obtainmessage () Gets the message object. This is not necessarily a straightforward creation of a new instance, but rather a message instance that is immediately available from the pool of messages, and is then fetched and returned to this instance. Conversely, if there is no message instance available in the pool, a new message object is given according to the parameter. By analyzing the source, it is known that the Android system instantiates 10 message objects in a messaging pool by default.

2.MessageQueue

Message Queuing, which holds the data structure of the message object and stores the message according to the "FIFO" principle. Storage is not a meaningful save, but instead the message object is concatenated in a linked list. MessageQueue objects do not need to be created by ourselves, but have looper objects to manage them, and a thread can have at most one MessageQueue. We can get the MessageQueue in the current thread through Looper.myqueue ().

3.Looper

MessageQueue manager, in a thread, if there is a Looper object, there must be a MessageQueue object, and there is only one Looper object and one MessageQueue object. In Android, except the main thread has the default Looper object, other threads have no Looper object by default. If you want our newly created thread to have a Looper object, we should first call the Looper.prepare () method and then call the Looper.loop () method. Typical usage is as follows:

1. class looperthread extends thread      
2. {      
3.     public handler  mHandler;      
4.     public void run ()       
5.     {      
6.         looper.prepare ();      
Li class= "alt" >        //other actions        that need to be handled;
7.         looper.loop ();      
8.     }      
9. }   

If the Looper object exists in our thread, we can get it through Looper.mylooper (), and we can get the Looper object of the main thread in the current application via Looper.getmainlooper (). One thing to note in this place is that if the Looper object is in the main thread of the application, Looper.mylooper () and Looper.getmainlooper () get the same object.

4.Handler

The processor of the message. Through the handler object we can encapsulate the message object and then add the message object to the MessageQueue through SendMessage (msg), and when MessageQueue loops to the message, The Handlemessage () method of the handler object corresponding to the message object is called to process it. Because the messages are processed in the Handlemessage () method, we should write a class that inherits from Handler and then handles the operations we need in Handlemessage ().

2. /**
4. *
6. * @author Coolszy
8. * @blog Http://blog.csdn.net/coolszy
10. *
12. */
14. public class Messageservice extends Service
18. {
20. private static final String TAG = "Messageservice";
22. private static final int KUKA = 0;
24. Private Looper Looper;
26. Private Servicehandler handler;
28. /**
30. * Because processing messages is in Handler's Handlemessage () method, we need to write our own class
32. * Inherit from the handler class, then write the function code we need in Handlemessage ()
34. * @author Coolszy
36. *
38. */
40. Private Final class Servicehandler extends Handler
42. {
44. Public Servicehandler (Looper Looper)
46. {
48. Super (Looper);
50. }
52. @Override
54. public void Handlemessage (Message msg)
56. {
58. Determine which message is based on what field
60. Switch (msg.what)
62. {
64. Case KUKA:
66. Gets the obj field of the MSG. We can write the function code we need here.
68. LOG.I (TAG, "The obj field of msg:" + msg.obj);
70. Break
72. Other cases
74. Default
76. Break
78. }
80. If our service has completed the task, stop the service
82. Stopself (MSG.ARG1);
84. }
86. }
88. @Override
90. public void OnCreate ()
92. {
94. LOG.I (TAG, "messageservice-->oncreate ()");
96. Service is run in the main thread by default, and services are typically time consuming, if
98. In the main thread, it will affect the interaction between the program and the user, so the service
100. Put in a separate thread to execute
102. Handlerthread thread = new Handlerthread ("Messagedemothread", Process.thread_priority_background);
104. Thread.Start ();
106. Gets the Looper object in the current thread
108. looper = thread.getlooper ();
110. Create a handler object and pass the Looper over to make handler,
112. Looper and MessageQueue Connect
114. handler = new Servicehandler (Looper);
116. }
118. @Override
120. public int Onstartcommand (Intent Intent, int flags, int startid)
122. {
124. LOG.I (TAG, "messageservice-->onstartcommand ()");
128. Get a message instance from the messaging pool
130. Message msg = handler.obtainmessage ();
132. Arg1 the ID of the save thread in the Handlemessage () method
134. We can stop the service by Stopself (Startid) method
136. msg.arg1 = Startid;
138. The Flag of MSG
140. msg.what = KUKA;
142. Here I create a Date object that assigns a value to the obj field
144. In practice we can pass the object we need to handle through obj
146. Date date = new Date ();
148. msg.obj = date;
150. Add MSG to the MessageQueue
152. Handler.sendmessage (msg);
154. return start_sticky;
156. }
158. @Override
160. public void OnDestroy ()
162. {
164. LOG.I (TAG, "messageservice-->ondestroy ()");
166. }
168. @Override
170. Public IBinder Onbind (Intent Intent)
172. {
174. return null;
176. }
178. }

Below we analyze how messages are handled in Android by tracking code. First put the test code:

Operation Result:

Note: In the test code we used the Handlerthread class, which is a subclass of thread, which will create the Looper object, which eliminates the hassle of writing our own thread subclasses and creating Looper.

Android messaging Mechanism (1)