Find Usages Diff Raw Download HTML Widget
Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions 
1
  /*
2
   * Copyright (C) 2006 The Android Open Source Project
3
   *
4
   * Licensed under the Apache License, Version 2.0 (the "License");
5
   * you may not use this file except in compliance with the License.
6
   * You may obtain a copy of the License at
7
   *
8
   *      http://www.apache.org/licenses/LICENSE-2.0
9
   *
10
  * Unless required by applicable law or agreed to in writing, software
11
  * distributed under the License is distributed on an "AS IS" BASIS,
12
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13
  * See the License for the specific language governing permissions and
14
  * limitations under the License.
15
  */
16
 
17
 package android.os;
18
 
Defines a message containing a description and arbitrary data object that can be sent to a Handler. This object contains two extra int fields and an extra object field that allow you to not do allocations in many cases.

While the constructor of Message is public, the best way to get one of these is to call Message.obtain() or one of the Handler.obtainMessage() methods, which will pull them from a pool of recycled objects.

33
 
34
 public final class Message implements Parcelable {
    
User-defined message code so that the recipient can identify what this message is about. Each Handler has its own name-space for message codes, so you do not need to worry about yours conflicting with other handlers. 
40
 
41
     public int what;

    
arg1 and arg2 are lower-cost alternatives to using setData() if you only need to store a few integer values. 
47
 
48
     public int arg1; 

    
arg1 and arg2 are lower-cost alternatives to using setData() if you only need to store a few integer values. 
54
 
55
     public int arg2;

    
An arbitrary object to send to the recipient. When using Messenger to send the message across processes this can only be non-null if it contains a Parcelable of a framework class (not one implemented by the application). For other data transfer use setData(android.os.Bundle).

Note that Parcelable objects here are not supported prior to the Build.VERSION_CODES.FROYO release. 

66
 
67
     public Object obj;

    
Optional Messenger where replies to this message can be sent. The semantics of exactly how this is used are up to the sender and receiver. 
73
 
74
     public Messenger replyTo;
75
     
76
     /*package*/ long when;
77
     
78
     /*package*/ Bundle data;
79
     
80
     /*package*/ Handler target;     
81
     
82
     /*package*/ Runnable callback;   
83
     
84
     // sometimes we store linked lists of these things
85
     /*package*/ Message next;
86
 
87
     private static Object mPoolSync = new Object();
88
     private static Message mPool;
89
     private static int mPoolSize = 0;
90
 
91
     private static final int MAX_POOL_SIZE = 10;
    
    
Return a new Message instance from the global pool. Allows us to avoid allocating new objects in many cases. 
96
 
97
     public static Message obtain() {
98
         synchronized () {
99
             if ( != null) {
100
                Message m = ;
101
                 = m.next;
102
                m.next = null;
103
                return m;
104
            }
105
        }
106
        return new Message();
107
    }

    
Same as obtain(), but copies the values of an existing message (including its target) into the new one.

Parameters:
orig Original message to copy.
Returns:
A Message object from the global pool.
115
    public static Message obtain(Message orig) {
116
        Message m = obtain();
117
        m.what = orig.what;
118
        m.arg1 = orig.arg1;
119
        m.arg2 = orig.arg2;
120
        m.obj = orig.obj;
121
        m.replyTo = orig.replyTo;
122
        if (orig.data != null) {
123
            m.data = new Bundle(orig.data);
124
        }
125
        m.target = orig.target;
126
        m.callback = orig.callback;
128
        return m;
129
    }

    
Same as obtain(), but sets the value for the target member on the Message returned.

Parameters:
h Handler to assign to the returned Message object's target member.
Returns:
A Message object from the global pool.
136
    public static Message obtain(Handler h) {
137
        Message m = obtain();
138
        m.target = h;
140
        return m;
141
    }

    
Same as obtain(android.os.Handler), but assigns a callback Runnable on the Message that is returned.

Parameters:
h Handler to assign to the returned Message object's target member.
callback Runnable that will execute when the message is handled.
Returns:
A Message object from the global pool.
150
    public static Message obtain(Handler h, Runnable callback) {
151
        Message m = obtain();
152
        m.target = h;
153
        m.callback = callback;
155
        return m;
156
    }

    
Same as obtain(), but sets the values for both target and what members on the Message.

Parameters:
h Value to assign to the target member.
what Value to assign to the what member.
Returns:
A Message object from the global pool.
165
    public static Message obtain(Handler h, int what) {
166
        Message m = obtain();
167
        m.target = h;
168
        m.what = what;
170
        return m;
171
    }

    
Same as obtain(), but sets the values of the target, what, and obj members.

Parameters:
h The target value to set.
what The what value to set.
obj The object method to set.
Returns:
A Message object from the global pool.
181
    public static Message obtain(Handler h, int what, Object obj) {
182
        Message m = obtain();
183
        m.target = h;
184
        m.what = what;
185
        m.obj = obj;
187
        return m;
188
    }

    
Same as obtain(), but sets the values of the target, what, arg1, and arg2 members.

Parameters:
h The target value to set.
what The what value to set.
arg1 The arg1 value to set.
arg2 The arg2 value to set.
Returns:
A Message object from the global pool.
200
    public static Message obtain(Handler h, int what, int arg1, int arg2) {
201
        Message m = obtain();
202
        m.target = h;
203
        m.what = what;
204
        m.arg1 = arg1;
205
        m.arg2 = arg2;
207
        return m;
208
    }

    
Same as obtain(), but sets the values of the target, what, arg1, arg2, and obj members.

Parameters:
h The target value to set.
what The what value to set.
arg1 The arg1 value to set.
arg2 The arg2 value to set.
obj The obj value to set.
Returns:
A Message object from the global pool.
221
    public static Message obtain(Handler h, int what, 
222
            int arg1, int arg2, Object obj) {
223
        Message m = obtain();
224
        m.target = h;
225
        m.what = what;
226
        m.arg1 = arg1;
227
        m.arg2 = arg2;
228
        m.obj = obj;
230
        return m;
231
    }

    
Return a Message instance to the global pool. You MUST NOT touch the Message after calling this function -- it has effectively been freed. 
238
    public void recycle() {
239
        synchronized () {
240
            if ( < ) {
241
                clearForRecycle();
242
                
243
                 = ;
244
                 = this;
245
            }
246
        }
247
    }

    
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. 
254
    public void copyFrom(Message o) {
255
        this. = o.what;
256
        this. = o.arg1;
257
        this. = o.arg2;
258
        this. = o.obj;
259
        this. = o.replyTo;
261
        if (o.data != null) {
262
            this. = (Bundle) o.data.clone();
263
        } else {
264
            this. = null;
265
        }
266
    }

    
Return the targeted delivery time of this message, in milliseconds. 
271
    public long getWhen() {
272
        return ;
273
    }
274
    
275
    public void setTarget(Handler target) {
276
        this. = target;
277
    }

    
Retrieve the a Handler implementation that will receive this message. The object must implement 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. 
287
    public Handler getTarget() {
288
        return ;
289
    }

    
Retrieve callback object that will execute when this message is handled. This object must implement Runnable. This is called by the target Handler that is receiving this Message to dispatch it. If not set, the message will be dispatched to the receiving Handler's Handler.handleMessage(Message Handler.handleMessage()). 
299
    public Runnable getCallback() {
300
        return ;
301
    }
    
    
Obtains a Bundle of arbitrary data associated with this event, lazily creating it if necessary. Set this value by calling setData(android.os.Bundle). Note that when transferring data across processes via Messenger, you will need to set your ClassLoader on the Bundle via Bundle.setClassLoader() so that it can instantiate your objects when you retrieve them.

See also:
peekData()
setData(android.os.Bundle)
314
    public Bundle getData() {
315
        if ( == null) {
316
             = new Bundle();
317
        }
318
        
319
        return ;
320
    }

    
Like getData(), but does not lazily create the Bundle. A null is returned if the Bundle does not already exist. See getData() for further information on this.

See also:
getData()
setData(android.os.Bundle)
329
    public Bundle peekData() {
330
        return ;
331
    }

    
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.

See also:
getData()
peekData()
339
    public void setData(Bundle data) {
340
        this. = data;
341
    }

    
Sends this Message to the Handler specified by getTarget(). Throws a null pointer exception if this field has not been set. 
347
    public void sendToTarget() {
348
        .sendMessage(this);
349
    }
351
    /*package*/ void clearForRecycle() {
352
         = 0;
353
         = 0;
354
         = 0;
355
         = null;
356
         = null;
357
         = 0;
358
         = null;
359
         = null;
360
         = null;
361
    }

    
Constructor (but the preferred way to get a Message is to call Message.obtain()). 
365
    public Message() {
366
    }
368
    public String toString() {
369
        StringBuilder   b = new StringBuilder();
370
        
371
        b.append("{ what=");
372
        b.append();
374
        b.append(" when=");
375
        b.append();
377
        if ( != 0) {
378
            b.append(" arg1=");
379
            b.append();
380
        }
382
        if ( != 0) {
383
            b.append(" arg2=");
384
            b.append();
385
        }
387
        if ( != null) {
388
            b.append(" obj=");
389
            b.append();
390
        }
392
        b.append(" }");
393
        
394
        return b.toString();
395
    }
397
    public static final Parcelable.Creator<Message> CREATOR
398
            = new Parcelable.Creator<Message>() {
399
        public Message createFromParcel(Parcel source) {
400
            Message msg = Message.obtain();
401
            msg.readFromParcel(source);
402
            return msg;
403
        }
404
        
405
        public Message[] newArray(int size) {
406
            return new Message[size];
407
        }
408
    };
409
        
410
    public int describeContents() {
411
        return 0;
412
    }
414
    public void writeToParcel(Parcel dest, int flags) {
415
        if ( != null) {
416
            throw new RuntimeException(
417
                "Can't marshal callbacks across processes.");
418
        }
419
        dest.writeInt();
420
        dest.writeInt();
421
        dest.writeInt();
422
        if ( != null) {
423
            try {
424
                Parcelable p = (Parcelable);
425
                dest.writeInt(1);
426
                dest.writeParcelable(p, flags);
427
            } catch (ClassCastException e) {
428
                throw new RuntimeException(
429
                    "Can't marshal non-Parcelable objects across processes.");
430
            }
431
        } else {
432
            dest.writeInt(0);
433
        }
434
        dest.writeLong();
435
        dest.writeBundle();
436
        Messenger.writeMessengerOrNullToParcel(, dest);
437
    }
439
    private final void readFromParcel(Parcel source) {
440
         = source.readInt();
441
         = source.readInt();
442
         = source.readInt();
443
        if (source.readInt() != 0) {
444
             = source.readParcelable(getClass().getClassLoader());
445
        }
446
         = source.readLong();
447
         = source.readBundle();
448
         = Messenger.readMessengerOrNullFromParcel(source);
449
    }
New to GrepCode? Check out our FAQ X