Learn more about the source code of the message in Android

I believe that everyone on the Android handler is familiar, but to know, handler on its own is only a shell, the real role in the internal function is the message class, for message this class, I believe we will not be unfamiliar, As you often use the Message.obtain () method. But do you know what the obtain () method does for us, and below I will lead you to the Kingdom of the message, to find out.

The first thing you'll be greeted with is this line of code:

[Java]View Plaincopyprint?

1. Public Final class Message implements Parcelable

Needless to say, the message implements the Parcelable interface, which means that the data encapsulated by the message can be transmitted through the intent and IPC. Now that the Parcelable interface is implemented, the three methods required in the message method: 1) Writetoparcel 2) describecontents 3) Createfromparcel.

The following four member variables we need to focus on are:

1) public int

2) public int arg1

3) public int arg2

4) Public Object obj

We often use a few of these parameters, but do their true meanings really understand? As long as Google's internal comments are truly reliable.

1) User-defined message identification code, so that the system can identify the current message is about what. Since each handle has its own namespace for the ID of its own message. So we don't have to worry about the conflict between the various handler.

2) where the second parameter is the same as the meaning of the third parameter, the note shows that the two parameters, if the user simply needs to transfer simple int type data, compared to SetData (bundle bundle), the cost is lower.

3) The fourth parameter, as described in the note, is understood as follows: This is a random data sent to the recipient, if the use of Messager to send data for cross-process communication, then the current obj if the implementation of parcelable must not be null pointer, For the transmission of other data, we generally use the SetData method. However, it is important to note that for versions higher than Android.os.build.version_codes#froyo, the parcelable objects here are not supported.

After the above variables are finished, we need to explain the definition of another set of constants:

[Java]View Plaincopyprint?

1. private static  final object spoolsync = new object ();   
2. private  static message spool;  
3. private  static int spoolsize =  0;  
4. //the largest size    in the pond;
5. private static  Final int max_pool_size = 50;  

At first glance, you may not understand the definition of the above four variables, if I remind you that the message in Android can be reused, then I believe you can roughly guess the meaning of these four variables.

1, the first variable is actually acting as a lock, to avoid multi-threaded scramble for resources, resulting in dirty data

2. Spool this variable can be interpreted as a pointer to the head of a message queue

3, Spoolsize is the length of the current message queue

4. Defines the maximum length of Message Queuing cache messages.

Ok, here, the member variables of the message have been explained, the next main is to explain the API method.

The first method is the obtain method that you often use, without any parameters:

[Java]View Plaincopyprint?

2. Public static Message obtain () {
4. synchronized (spoolsync) {
6. if (sPool! = null) {
8. Message m = sPool;
10. SPool = M.next;
12. M.next = null;
14. spoolsize--;
16. return m;
18. }
20. }
22. return new Custommessage ();
24. }

First, in order to avoid multi-threading to scramble for resources, Spoolsync to lock. First, determine if the current queue pointer is empty, if the current pointer is not empty, the current queue header message can be reused and taken out, then the current queue of the head pointer to the current message of the next message, that is, M.next, at the same time, the trailing pointer of the extracted message is set to NULL, The length of the queue is reduced by 1.

A second method:

[Java]View Plaincopyprint?

2. Public static message obtain (message orig) {
4. Message m = obtain ();
6. M.what = Orig.what;
8. M.ARG1 = ORIG.ARG1;
10. M.ARG2 = ORIG.ARG2;
12. M.obj = Orig.obj;
14. M.replyto = Orig.replyto;
16. if (orig.data! = null) {
18. M.data = new Bundle (Orig.data);
20. }
22. M.target = Orig.target;
24. M.callback = Orig.callback;
26. return m;
28. }

As we can see, this method has a orig parameter compared to the above method, and from the above code we can see that the object of the message is taken out of the queue first, then the individual data of the object in which the parameter is copied, and finally the object is returned.

The third method is as follows:

[Java]View Plaincopyprint?

1. Public static Message obtain (Handler h) {
2. Message m = obtain ();
3. M.target = h;
4. return m;
5. }

Needless to say, this function specifies a handler object for the currently created message because we know that handler is the final destination of the message.

[Java]View Plaincopyprint?

1. Public static Message obtain (Handler H, Runnable callback) {
2. Message m = obtain ();
3. M.target = h;
4. M.callback = callback;
5. return m;
6. }

Compared to the above method, there is a line M.callback = callback, according to the note above, when some messages are actually executed, callback this Runnbale method will be triggered execution.

Then there is the logic of a series of methods that are similar, and we take one of them to explain:

[Java]View Plaincopyprint?

2. Public static Message obtain (Handler H, int. What, int arg1, int arg2) {
4. Message m = obtain ();
6. M.target = h;
8. M.what = what;
10. M.ARG1 = arg1;
12. M.ARG2 = arg2;
14. return m;
16. }

This means that when you create a message, you can provide some logically needed arguments for the message.

Message is created, then there must be a concept of recycling, let's look at:

[Java]View Plaincopyprint?

2. Public void Recycle () {
4. Clearforrecycle ();
6. synchronized (spoolsync) {
8. if (Spoolsize < max_pool_size) {
10. Next = SPool;
12. SPool = this ;
14. spoolsize++;
16. }
18. }
20. }
22. <pre name="code" class="java" >void Clearforrecycle () {
24. Flags = 0;
26. what = 0;
28. Arg1 = 0;
30. Arg2 = 0;
32. obj = null;
34. ReplyTo = null;
36. when = 0;
38. target = null;
40. callback = null;
42. data = null;
44. }

In Clearforrecycle, this function is to do some preprocessing of the recovery, the parameter set to 0 is set to 0, the null parameter is set to NULL. In the Recycle function, the current message is added to the end of the queue as long as the current cached queue length does not exceed the upper limit.

The following methods are required to implement parcelable:

[Java]View Plaincopyprint?

2. Public static final parcelable.creator<custommessage> Creator
4. = New Parcelable.creator<custommessage> () {
6. Public Message Createfromparcel (Parcel source) {
8. Message msg = Message.obtain ();
10. Msg.readfromparcel (source);
12. return msg;
14. }
18. Public message[] NewArray (int size) {
20. return new message[size];
22. }
24. };
28. public int describecontents () {
30. return 0;
32. }
36. public void Writetoparcel (Parcel dest, int flags) {
38. if (callback! = null) {
40. throw New RuntimeException (
42. "Can ' t marshal callbacks across processes.");
44. }
46. Dest.writeint (what);
48. Dest.writeint (ARG1);
50. Dest.writeint (ARG2);
52. if (obj! = null) {
54. try {
56. Parcelable p = (parcelable) obj;
58. Dest.writeint (1);
60. Dest.writeparcelable (P, flags);
62. } catch (ClassCastException e) {
64. throw New RuntimeException (
66. "Can ' t marshal non-parcelable objects across processes.");
68. }
70. } Else {
72. Dest.writeint (0);
74. }
76. Dest.writelong (when);
78. Dest.writebundle (data);
80. Messenger.writemessengerornulltoparcel (ReplyTo, dest);
82. }
86. private void Readfromparcel (Parcel source) {
88. what = Source.readint ();
90. Arg1 = Source.readint ();
92. Arg2 = Source.readint ();
94. if (source.readint ()! = 0) {
96. obj = source.readparcelable (GetClass (). getClassLoader ());
98. }
100. when = Source.readlong ();
102. data = Source.readbundle ();
104. ReplyTo = Messenger.readmessengerornullfromparcel (source);
106. }

Ok,message of the core source of the analysis is explained here

Learn more about the source code of the message in Android