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