/**@class android.os.Messenger
 implements android.os.Parcelable

@extends java.lang.Object

 Reference to a Handler, which others can use to send messages to it.
 This allows for the implementation of message-based communication across
 processes, by creating a Messenger pointing to a Handler in one process,
 and handing that Messenger to another process.

 <p>Note: the implementation underneath is just a simple wrapper around
 a {@link android.os.Binder} that is used to perform the communication.  This means
 semantically you should treat it as such: this class does not impact process
 lifecycle management (you must be using some higher-level component to tell
 the system that your process needs to continue running), the connection will
 break if your process goes away for any reason, etc.</p>
*/
var Messenger = {

/***/
CREATOR : "null",
/**Send a Message to this Messenger's Handler.
@param {Object {Message}} message The Message to send.  Usually retrieved through
 {@link Message#obtain() Message.obtain()}.
@throws RemoteException Throws DeadObjectException if the target
 Handler no longer exists.
*/
send : function(  ) {},

/**Retrieve the IBinder that this Messenger is using to communicate with
 its associated Handler.
@return {Object {android.os.IBinder}} Returns the IBinder backing this Messenger.
*/
getBinder : function(  ) {},

/**Comparison operator on two Messenger objects, such that true
 is returned then they both point to the same Handler.
*/
equals : function(  ) {},

/**
*/
hashCode : function(  ) {},

/**
*/
describeContents : function(  ) {},

/**
*/
writeToParcel : function(  ) {},

/**Convenience function for writing either a Messenger or null pointer to
 a Parcel.  You must use this with {@link #readMessengerOrNullFromParcel}
 for later reading it.
@param {Object {Messenger}} messenger The Messenger to write, or null.
@param {Object {Parcel}} out Where to write the Messenger.
*/
writeMessengerOrNullToParcel : function(  ) {},

/**Convenience function for reading either a Messenger or null pointer from
 a Parcel.  You must have previously written the Messenger with
 {@link #writeMessengerOrNullToParcel}.
@param {Object {Parcel}} in The Parcel containing the written Messenger.
@return {Object {android.os.Messenger}} Returns the Messenger read from the Parcel, or null if null had
 been written.
*/
readMessengerOrNullFromParcel : function(  ) {},


};