| Methods Summary |
|---|
| void | clearForRecycle()
what = 0;
arg1 = 0;
arg2 = 0;
obj = null;
replyTo = null;
when = 0;
target = null;
callback = null;
data = null;
|
| public void | copyFrom(Message o)Make this message like o. Performs a shallow copy of the data field.
Does not copy the linked list fields, nor the timestamp or
target/callback of the original message.
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 int | describeContents()
return 0;
|
| public java.lang.Runnable | getCallback()Retrieve callback object that will execute when this message is handled.
This object must implement Runnable. This is called by
the target {@link Handler} that is receiving this Message to
dispatch it. If
not set, the message will be dispatched to the receiving Handler's
{@link Handler#handleMessage(Message Handler.handleMessage())}.
return callback;
|
| public android.os.Bundle | getData()Obtains a Bundle of arbitrary data associated with this
event, lazily creating it if necessary. Set this value by calling {@link #setData(Bundle)}.
if (data == null) {
data = new Bundle();
}
return data;
|
| public Handler | getTarget()Retrieve the a {@link android.os.Handler Handler} implementation that
will receive this message. The object must implement
{@link android.os.Handler#handleMessage(android.os.Message)
Handler.handleMessage()}. Each Handler has its own name-space for
message codes, so you do not need to
worry about yours conflicting with other handlers.
return target;
|
| public long | getWhen()Return the targeted delivery time of this message, in milliseconds.
return when;
|
| public static Message | obtain()Return a new Message instance from the global pool. Allows us to
avoid allocating new objects in many cases.
synchronized (mPoolSync) {
if (mPool != null) {
Message m = mPool;
mPool = m.next;
m.next = null;
return m;
}
}
return new Message();
|
| public static Message | obtain(Message orig)Same as {@link #obtain()}, but copies the values of an existing
message (including its target) into the new one.
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;
|
| public static Message | obtain(Handler h)Same as {@link #obtain()}, but sets the value for the target member on the Message returned.
Message m = obtain();
m.target = h;
return m;
|
| public static Message | obtain(Handler h, java.lang.Runnable callback)Same as {@link #obtain(Handler)}, but assigns a callback Runnable on
the Message that is returned.
Message m = obtain();
m.target = h;
m.callback = callback;
return m;
|
| public static Message | obtain(Handler h, int what)Same as {@link #obtain()}, but sets the values for both target and
what members on the Message.
Message m = obtain();
m.target = h;
m.what = what;
return m;
|
| public static Message | obtain(Handler h, int what, java.lang.Object obj)Same as {@link #obtain()}, but sets the values of the target, what, and obj
members.
Message m = obtain();
m.target = h;
m.what = what;
m.obj = obj;
return m;
|
| public static Message | obtain(Handler h, int what, int arg1, int arg2)Same as {@link #obtain()}, but sets the values of the target, what,
arg1, and arg2 members.
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, java.lang.Object obj)Same as {@link #obtain()}, but sets the values of the target, what,
arg1, arg2, and obj members.
Message m = obtain();
m.target = h;
m.what = what;
m.arg1 = arg1;
m.arg2 = arg2;
m.obj = obj;
return m;
|
| public android.os.Bundle | peekData()Like getData(), but does not lazily create the Bundle. A null
is returned if the Bundle does not already exist.
return data;
|
| private final void | readFromParcel(android.os.Parcel source)
what = source.readInt();
arg1 = source.readInt();
arg2 = source.readInt();
when = source.readLong();
data = source.readBundle();
replyTo = Messenger.readMessengerOrNullFromParcel(source);
|
| public void | recycle()Return a Message instance to the global pool. You MUST NOT touch
the Message after calling this function -- it has effectively been
freed.
synchronized (mPoolSync) {
if (mPoolSize < MAX_POOL_SIZE) {
clearForRecycle();
next = mPool;
mPool = this;
}
}
|
| public void | sendToTarget()Sends this Message to the Handler specified by {@link #getTarget}.
Throws a null pointer exception if this field has not been set.
target.sendMessage(this);
|
| public void | setData(android.os.Bundle data)Sets a Bundle of arbitrary data values. Use arg1 and arg1 members
as a lower cost way to send a few simple integer values, if you can.
this.data = data;
|
| public void | setTarget(Handler target)
this.target = target;
|
| public java.lang.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 void | writeToParcel(android.os.Parcel dest, int flags)
if (obj != null || callback != null) {
throw new RuntimeException(
"Can't marshal objects across processes.");
}
dest.writeInt(what);
dest.writeInt(arg1);
dest.writeInt(arg2);
dest.writeLong(when);
dest.writeBundle(data);
Messenger.writeMessengerOrNullToParcel(replyTo, dest);
|
