/**@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 = {

/**@hide */
CHECK_PARCEL_SIZE : "false",
/**@hide */
LOG_RUNTIME_EXCEPTION : "null",
/** Value to represents that a calling work source is not set.

 This constatnt needs to be kept in sync with IPCThreadState::kUnsetWorkSource.

 @hide
*/
UNSET_WORKSOURCE : "-1",
/**Enable Binder IPC tracing.
@hide 
*/
enableTracing : function(  ) {},

/**Disable Binder IPC tracing.
@hide 
*/
disableTracing : function(  ) {},

/**Check if binder transaction tracing is enabled.
@hide 
*/
isTracingEnabled : function(  ) {},

/**Get the binder transaction tracker for this process.
@hide 
*/
getTransactionTracker : function(  ) {},

/**Get the binder transaction observer for this process.
@hide 
*/
setObserver : function(  ) {},

/**Warn if any blocking binder transactions are made out from this process.
 This is typically only useful for the system process, to prevent it from
 blocking on calls to external untrusted code. Instead, all outgoing calls
 that require a result must be sent as {@link android.os.IBinder#FLAG_ONEWAY} calls
 which deliver results through a callback interface.
@hide 
*/
setWarnOnBlocking : function(  ) {},

/**Allow blocking calls on the given interface, overriding the requested
 value of {@link #setWarnOnBlocking}(boolean).
 <p>
 This should only be rarely called when you are <em>absolutely sure</em>
 the remote interface is a built-in system component that can never be
 upgraded. In particular, this <em>must never</em> be called for
 interfaces hosted by package that could be upgraded or replaced,
 otherwise you risk system instability if that remote interface wedges.
@hide 
*/
allowBlocking : function(  ) {},

/**Reset the given interface back to the default blocking behavior,
 reverting any changes made by {@link #allowBlocking}(IBinder).
@hide 
*/
defaultBlocking : function(  ) {},

/**Inherit the current {@link #allowBlocking}(IBinder) value from one given
 interface to another.
@hide 
*/
copyAllowBlocking : function(  ) {},

/**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(  ) {},

/**Returns {@code true} if the current thread is currently executing an
 incoming transaction.
@hide 
*/
isHandlingTransaction : function(  ) {},

/**Return the Linux uid assigned to the process that sent the transaction
 currently being processed.
@throws IllegalStateException if the current thread is not currently
        executing an incoming transaction.
*/
getCallingUidOrThrow : 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(  ) {},

/**Convenience method for running the provided action enclosed in
 {@link #clearCallingIdentity}/{@link #restoreCallingIdentity}

 Any exception thrown by the given action will be caught and rethrown after the call to
 {@link #restoreCallingIdentity}
@hide 
*/
withCleanCallingIdentity : function(  ) {},

/**Convenience method for running the provided action enclosed in
 {@link #clearCallingIdentity}/{@link #restoreCallingIdentity} returning the result

 Any exception thrown by the given action will be caught and rethrown after the call to
 {@link #restoreCallingIdentity}
@hide 
*/
withCleanCallingIdentity : 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(  ) {},

/**Sets the work source for this thread.

 <p>All the following binder calls on this thread will use the provided work source. If this
 is called during an on-going binder transaction, all the following binder calls will use the
 work source until the end of the transaction.

 <p>The concept of worksource is similar to {@link android.os.WorkSource}. However, for performance
 reasons, we only support one UID. This UID represents the original user responsible for the
 binder calls.

 <p>{@link android.os.Binder#restoreCallingWorkSource(long)} must always be called after setting the
 worksource.

 <p>A typical use case would be
 <pre>
 long token = Binder.setCallingWorkSourceUid(uid);
 try {
   // Call an API.
 } finally {
   Binder.restoreCallingWorkSource(token);
 }
 </pre>

 <p>The work source will be propagated for future outgoing binder transactions
 executed on this thread.
@param {Number} workSource The original UID responsible for the binder call.
@return {Number} token to restore original work source.
*/
setCallingWorkSourceUid : function(  ) {},

/**Returns the work source set by the caller.

 Unlike {@link android.os.Binder#getCallingUid()}, this result of this method cannot be trusted. The
 caller can set the value to whatever they want. Only use this value if you trust the calling
 uid.
@return {Number} The original UID responsible for the binder transaction.
*/
getCallingWorkSourceUid : function(  ) {},

/**Clears the work source on this thread.

 <p>The work source will be propagated for future outgoing binder transactions
 executed on this thread.

 <p>{@link android.os.Binder#restoreCallingWorkSource(long)} must always be called after clearing the
 worksource.

 <p>A typical use case would be
 <pre>
 long token = Binder.clearCallingWorkSource();
 try {
   // Call an API.
 } finally {
   Binder.restoreCallingWorkSource(token);
 }
 </pre>
@return {Number} token to restore original work source.
*/
clearCallingWorkSource : function(  ) {},

/**Restores the work source on this thread using a token returned by
 {@link #setCallingWorkSourceUid(int) or {@link clearCallingWorkSource}().

 <p>A typical use case would be
 <pre>
 long token = Binder.setCallingWorkSourceUid(uid);
 try {
   // Call an API.
 } finally {
   Binder.restoreCallingWorkSource(token);
 }
 </pre>
*/
restoreCallingWorkSource : 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(  ) {},

/**Sets a listener for the transact method on the proxy-side.

 <li>The listener is global. Only fast operations should be done to avoid thread
 contentions.
 <li>The listener implementation needs to handle synchronization if needed. The methods on the
 listener can be called concurrently.
 <li>Listener set will be used for new transactions. On-going transaction will still use the
 previous listener (if already set).
 <li>The listener is called on the critical path of the binder transaction so be careful about
 performance.
 <li>Never execute another binder transaction inside the listener.
@hide 
*/
setProxyTransactListener : function(  ) {},

/**Resolves a transaction code to a human readable name.

 <p>Default implementation is a stub that returns null.
 <p>AIDL generated code will return the original method name.
@param {Number} transactionCode The code to resolve.
@return {String} A human readable name.
@hide 
*/
getTransactionName : 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(  ) {},

/**
@param {Object {FileDescriptor}} in The raw file descriptor that an input data stream can be read from.
@param {Object {FileDescriptor}} out The raw file descriptor that normal command messages should be written to.
@param {Object {FileDescriptor}} err The raw file descriptor that command error messages should be written to.
@param {Object {java.lang.String[]}} args Command-line arguments.
@param {Object {ShellCallback}} callback Callback through which to interact with the invoking shell.
@param {Object {ResultReceiver}} resultReceiver Called when the command has finished executing, with the result code.
@throws RemoteException
@hide 
*/
shellCommand : function(  ) {},

/**Handle a call to {@link #shellCommand}.  The default implementation simply prints
 an error message.  Override and replace with your own.
 <p class="caution">Note: no permission checking is done before calling this method; you must
 apply any security checks as appropriate for the command being executed.
 Consider using {@link android.os.ShellCommand} to help in the implementation.</p>
@hide 
*/
onShellCommand : 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(  ) {},

/**Sets the work source provider.

 <li>The callback is global. Only fast operations should be done to avoid thread
 contentions.
 <li>The callback implementation needs to handle synchronization if needed. The methods on the
 callback can be called concurrently.
 <li>The callback is called on the critical path of the binder transaction so be careful about
 performance.
 <li>Never execute another binder transaction inside the callback.
@hide 
*/
setWorkSourceProvider : function(  ) {},


};