/**@class android.os.Binder
 implements android.os.IBinder

@extends java.lang.Object

 Base class for a remotable object, the core part of a lightweight
 remote procedure call mechanism defined by {@link android.os.IBinder}.
 This class is an implementation of IBinder that provides
 standard local implementation of such an object.

 <p>Most developers will not implement this class directly, instead using the
 <a href="{@docRoot}guide/components/aidl.html">aidl</a> tool to describe the desired
 interface, having it generate the appropriate Binder subclass.  You can,
 however, derive directly from Binder to implement your own custom RPC
 protocol or simply instantiate a raw Binder object directly to use as a
 token that can be shared across processes.

 <p>This class is just a basic IPC primitive; it has no impact on an application's
 lifecycle, and is valid only as long as the process that created it continues to run.
 To use this correctly, you must be doing so within the context of a top-level
 application component (a {@link android.app.Service}, {@link android.app.Activity},
 or {@link android.content.ContentProvider}) that lets the system know your process
 should remain running.</p>

 <p>You must keep in mind the situations in which your process
 could go away, and thus require that you later re-create a new Binder and re-attach
 it when the process starts again.  For example, if you are using this within an
 {@link android.app.Activity}, your activity's process may be killed any time the
 activity is not started; if the activity is later re-created you will need to
 create a new Binder and hand it back to the correct place again; you need to be
 aware that your process may be started for another reason (for example to receive
 a broadcast) that will not involve re-creating the activity and thus run its code
 to create a new Binder.</p>

 @see IBinder
*/
var Binder = {

/**Return the ID of the process that sent you the current transaction
 that is being processed.  This pid can be used with higher-level
 system services to determine its identity and check permissions.
 If the current thread is not currently executing an incoming transaction,
 then its own pid is returned.
*/
getCallingPid : function(  ) {},

/**Return the Linux uid assigned to the process that sent you the
 current transaction that is being processed.  This uid can be used with
 higher-level system services to determine its identity and check
 permissions.  If the current thread is not currently executing an
 incoming transaction, then its own uid is returned.
*/
getCallingUid : function(  ) {},

/**Return the UserHandle assigned to the process that sent you the
 current transaction that is being processed.  This is the user
 of the caller.  It is distinct from {@link #getCallingUid}() in that a
 particular user will have multiple distinct apps running under it each
 with their own uid.  If the current thread is not currently executing an
 incoming transaction, then its own UserHandle is returned.
*/
getCallingUserHandle : function(  ) {},

/**Reset the identity of the incoming IPC on the current thread.  This can
 be useful if, while handling an incoming call, you will be calling
 on interfaces of other objects that may be local to your process and
 need to do permission checks on the calls coming into them (so they
 will check the permission of your own local process, and not whatever
 process originally called you).
@return {Number} Returns an opaque token that can be used to restore the
 original calling identity by passing it to
 {@link #restoreCallingIdentity(long)}.
@see #getCallingPid()
@see #getCallingUid()
@see #restoreCallingIdentity(long)
*/
clearCallingIdentity : function(  ) {},

/**Restore the identity of the incoming IPC on the current thread
 back to a previously identity that was returned by {@link #clearCallingIdentity}.
@param {Number} token The opaque token that was previously returned by
 {@link #clearCallingIdentity}.
@see #clearCallingIdentity
*/
restoreCallingIdentity : function(  ) {},

/**Sets the native thread-local StrictMode policy mask.

 <p>The StrictMode settings are kept in two places: a Java-level
 threadlocal for libcore/Dalvik, and a native threadlocal (set
 here) for propagation via Binder calls.  This is a little
 unfortunate, but necessary to break otherwise more unfortunate
 dependencies either of Dalvik on Android, or Android
 native-only code on Dalvik.
@see StrictMode
@hide 
*/
setThreadStrictModePolicy : function(  ) {},

/**Gets the current native thread-local StrictMode policy mask.
@see #setThreadStrictModePolicy
@hide 
*/
getThreadStrictModePolicy : function(  ) {},

/**Flush any Binder commands pending in the current thread to the kernel
 driver.  This can be
 useful to call before performing an operation that may block for a long
 time, to ensure that any pending object references have been released
 in order to prevent the process from holding on to objects longer than
 it needs to.
*/
flushPendingCommands : function(  ) {},

/**Add the calling thread to the IPC thread pool.  This function does
 not return until the current process is exiting.
*/
joinThreadPool : function(  ) {},

/**Returns true if the specified interface is a proxy.
@hide 
*/
isProxy : function(  ) {},

/**Call blocks until the number of executing binder threads is less
 than the maximum number of binder threads allowed for this process.
@hide 
*/
blockUntilThreadAvailable : function(  ) {},

/**Convenience method for associating a specific interface with the Binder.
 After calling, queryLocalInterface() will be implemented for you
 to return the given owner IInterface when the corresponding
 descriptor is requested.
*/
attachInterface : function(  ) {},

/**Default implementation returns an empty interface name.
*/
getInterfaceDescriptor : function(  ) {},

/**Default implementation always returns true -- if you got here,
 the object is alive.
*/
pingBinder : function(  ) {},

/**{@inheritDoc}

 Note that if you're calling on a local binder, this always returns true
 because your process is alive if you're calling it.
*/
isBinderAlive : function(  ) {},

/**Use information supplied to attachInterface() to return the
 associated IInterface if it matches the requested
 descriptor.
*/
queryLocalInterface : function(  ) {},

/**Control disabling of dump calls in this process.  This is used by the system
 process watchdog to disable incoming dump calls while it has detecting the system
 is hung and is reporting that back to the activity controller.  This is to
 prevent the controller from getting hung up on bug reports at this point.
@param {String} msg The message to show instead of the dump; if null, dumps are
 re-enabled.
@param msg The message to show instead of the dump; if null, dumps are
 re-enabled.
*/
setDumpDisabled : function(  ) {},

/**Implemented to call the more convenient version
 {@link #dump(FileDescriptor, PrintWriter, String[])}.
*/
dump : function(  ) {},

/**Like {@link #dump(FileDescriptor, String[])}, but ensures the target
 executes asynchronously.
*/
dumpAsync : function(  ) {},

/**Default implementation rewinds the parcels and calls onTransact.  On
 the remote side, transact calls into the binder to do the IPC.
*/
transact : function(  ) {},

/**Local implementation is a no-op.
*/
linkToDeath : function(  ) {},

/**Local implementation is a no-op.
*/
unlinkToDeath : function(  ) {},


};