[源码分析]Android消息机制之Message类

package android.os;
import android.os.Bundle;
import android.os.Parcel;
import android.os.Parcelable;
public final class Message implements Parcelable {//可序列化;
public int what;//消息标识;
public int arg1;//附带Integer参数 1;
public int arg2;//附带Integer参数 2;
public Object obj;//附带对象参数 obj;
public Messenger replyTo;
long when; //时间;
Bundle data;//Bundle数据结构;
Handler target;//目标Handler主要管理消息的接受与发送;
Runnable callback; // Runnable对象;
Message next;//下一条;
private static Object mPoolSync = new Object();//同步锁;
private static Message mPool;//消息池的消息;
private static int mPoolSize = 0;//默认消息数;
private static final int MAX_POOL_SIZE = 10;//总数;

/**
* 类方法,返回一个Message;
*/
public static Message obtain() {
synchronized (mPoolSync) {//同步;
if (mPool != null) {
Message m = mPool;//得到mPool;
mPool = m.next;
m.next = null;
return m;
}
}
return new Message();
}

/**
* 类方法,复制一个Message;;
*/
public static Message obtain(Message orig) {
Message m = obtain();
m.what = orig.what;
m.arg1 = orig.arg1;
m.arg2 = orig.arg2;
m.obj = orig.obj;
m.replyTo = orig.replyTo;
if (orig.data != null) {
m.data = new Bundle(orig.data);
}
m.target = orig.target;
m.callback = orig.callback;
return m;
}

/**
* 类方法,绑定一个Handler的Message;
*/
public static Message obtain(Handler h) {
Message m = obtain();
m.target = h;
return m;
}

/**
* 类方法,绑定一个Handler和Runnalbe的Message;
*/
public static Message obtain(Handler h, Runnable callback) {
Message m = obtain();
m.target = h;
m.callback = callback;
return m;
}

/**
* 类方法,绑定一个Handler和一个消息标识;
*/
public static Message obtain(Handler h, int what) {
Message m = obtain();
m.target = h;
m.what = what;
return m;
}

/**
* 类方法,绑定一个Handler和一个消息标识,和一个对象形参;
*/
public static Message obtain(Handler h, int what, Object obj) {
Message m = obtain();
m.target = h;
m.what = what;
m.obj = obj;
return m;
}

/**
* 类方法,绑定一个Handler和两个消息标识,和一个对象形参;
*/
public static Message obtain(Handler h, int what, int arg1, int arg2) {
Message m = obtain();
m.target = h;
m.what = what;
m.arg1 = arg1;
m.arg2 = arg2;
return m;
}
public static Message obtain(Handler h, int what,
int arg1, int arg2, Object obj) {
Message m = obtain();
m.target = h;
m.what = what;
m.arg1 = arg1;
m.arg2 = arg2;
m.obj = obj;

return m;
}
/**
* 回收消息;
*/
public void recycle() {
synchronized (mPoolSync) {
if (mPoolSize < MAX_POOL_SIZE) {
clearForRecycle();
next = mPool;
mPool = this;
}
}
}

/**
* 复制消息;
*/
public void copyFrom(Message o) {
this.what = o.what;
this.arg1 = o.arg1;
this.arg2 = o.arg2;
this.obj = o.obj;
this.replyTo = o.replyTo;

if (o.data != null) {
this.data = (Bundle) o.data.clone();
} else {
this.data = null;
}
}

//设置时间;
public long getWhen() {
return when;
}

//设置handler;
public void setTarget(Handler target) {
this.target = target;
}

public Handler getTarget() {
return target;
}

public Runnable getCallback() {
return callback;
}

public Bundle getData() {
if (data == null) {
data = new Bundle();
}

return data;
}

public Bundle peekData() {
return data;
}

//设置data;
public void setData(Bundle data) {
this.data = data;
}

//通过目标Handler target发送消息;
public void sendToTarget() {
target.sendMessage(this);
}

/*package*/ void clearForRecycle() {
what = 0;
arg1 = 0;
arg2 = 0;
obj = null;
replyTo = null;
when = 0;
target = null;
callback = null;
data = null;
}

public Message() {
}

public String toString() {
StringBuilder   b = new StringBuilder();

b.append("{ what=");
b.append(what);

b.append(" when=");
b.append(when);

if (arg1 != 0) {
b.append(" arg1=");
b.append(arg1);
}

if (arg2 != 0) {
b.append(" arg2=");
b.append(arg2);
}

if (obj != null) {
b.append(" obj=");
b.append(obj);
}

b.append(" }");

return b.toString();
}

//消息的序列化;
public static final Parcelable.Creator<Message> CREATOR
= new Parcelable.Creator<Message>() {
public Message createFromParcel(Parcel source) {
Message msg = Message.obtain();
msg.readFromParcel(source);
return msg;
}

public Message[] newArray(int size) {
return new Message[size];
}
};

public int describeContents() {
return 0;
}

public void writeToParcel(Parcel dest, int flags) {
if (callback != null) {
throw new RuntimeException(
"Can't marshal callbacks across processes.");
}
dest.writeInt(what);
dest.writeInt(arg1);
dest.writeInt(arg2);
if (obj != null) {
try {
Parcelable p = (Parcelable)obj;
dest.writeInt(1);
dest.writeParcelable(p, flags);
} catch (ClassCastException e) {
throw new RuntimeException(
"Can't marshal non-Parcelable objects across processes.");
}
} else {
dest.writeInt(0);
}
dest.writeLong(when);
dest.writeBundle(data);
Messenger.writeMessengerOrNullToParcel(replyTo, dest);
}

private final void readFromParcel(Parcel source) {
what = source.readInt();
arg1 = source.readInt();
arg2 = source.readInt();
if (source.readInt() != 0) {
obj = source.readParcelable(getClass().getClassLoader());
}
when = source.readLong();
data = source.readBundle();
replyTo = Messenger.readMessengerOrNullFromParcel(source);
}
}