| Methods Summary |
|---|
| public void | attachInterface(IInterface owner, java.lang.String descriptor)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.
mOwner = owner;
mDescriptor = descriptor;
|
| static void | checkParcel(IBinder obj, int code, Parcel parcel, java.lang.String msg)
if (CHECK_PARCEL_SIZE && parcel.dataSize() >= 800*1024) {
// Trying to send > 800k, this is way too much
StringBuilder sb = new StringBuilder();
sb.append(msg);
sb.append(": on ");
sb.append(obj);
sb.append(" calling ");
sb.append(code);
sb.append(" size ");
sb.append(parcel.dataSize());
sb.append(" (data: ");
parcel.setDataPosition(0);
sb.append(parcel.readInt());
sb.append(", ");
sb.append(parcel.readInt());
sb.append(", ");
sb.append(parcel.readInt());
sb.append(")");
Slog.wtfStack(TAG, sb.toString());
}
|
| public static final native long | clearCallingIdentity()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).
|
| private final native void | destroy()
|
| public void | dump(java.io.FileDescriptor fd, java.lang.String[] args)Implemented to call the more convenient version
{@link #dump(FileDescriptor, PrintWriter, String[])}.
FileOutputStream fout = new FileOutputStream(fd);
PrintWriter pw = new FastPrintWriter(fout);
try {
final String disabled;
synchronized (Binder.class) {
disabled = sDumpDisabled;
}
if (disabled == null) {
try {
dump(fd, pw, args);
} catch (SecurityException e) {
pw.println("Security exception: " + e.getMessage());
throw e;
} catch (Throwable e) {
// Unlike usual calls, in this case if an exception gets thrown
// back to us we want to print it back in to the dump data, since
// that is where the caller expects all interesting information to
// go.
pw.println();
pw.println("Exception occurred while dumping:");
e.printStackTrace(pw);
}
} else {
pw.println(sDumpDisabled);
}
} finally {
pw.flush();
}
|
| protected void | dump(java.io.FileDescriptor fd, java.io.PrintWriter fout, java.lang.String[] args)Print the object's state into the given stream.
|
| public void | dumpAsync(java.io.FileDescriptor fd, java.lang.String[] args)Like {@link #dump(FileDescriptor, String[])}, but ensures the target
executes asynchronously.
final FileOutputStream fout = new FileOutputStream(fd);
final PrintWriter pw = new FastPrintWriter(fout);
Thread thr = new Thread("Binder.dumpAsync") {
public void run() {
try {
dump(fd, pw, args);
} finally {
pw.flush();
}
}
};
thr.start();
|
| private boolean | execTransact(int code, long dataObj, long replyObj, int flags)
Parcel data = Parcel.obtain(dataObj);
Parcel reply = Parcel.obtain(replyObj);
// theoretically, we should call transact, which will call onTransact,
// but all that does is rewind it, and we just got these from an IPC,
// so we'll just call it directly.
boolean res;
// Log any exceptions as warnings, don't silently suppress them.
// If the call was FLAG_ONEWAY then these exceptions disappear into the ether.
try {
res = onTransact(code, data, reply, flags);
} catch (RemoteException e) {
if ((flags & FLAG_ONEWAY) != 0) {
Log.w(TAG, "Binder call failed.", e);
} else {
reply.setDataPosition(0);
reply.writeException(e);
}
res = true;
} catch (RuntimeException e) {
if ((flags & FLAG_ONEWAY) != 0) {
Log.w(TAG, "Caught a RuntimeException from the binder stub implementation.", e);
} else {
reply.setDataPosition(0);
reply.writeException(e);
}
res = true;
} catch (OutOfMemoryError e) {
// Unconditionally log this, since this is generally unrecoverable.
Log.e(TAG, "Caught an OutOfMemoryError from the binder stub implementation.", e);
RuntimeException re = new RuntimeException("Out of memory", e);
reply.setDataPosition(0);
reply.writeException(re);
res = true;
}
checkParcel(this, code, reply, "Unreasonably large binder reply buffer");
reply.recycle();
data.recycle();
// Just in case -- we are done with the IPC, so there should be no more strict
// mode violations that have gathered for this thread. Either they have been
// parceled and are now in transport off to the caller, or we are returning back
// to the main transaction loop to wait for another incoming transaction. Either
// way, strict mode begone!
StrictMode.clearGatheredViolations();
return res;
|
| protected void | finalize()
try {
destroy();
} finally {
super.finalize();
}
|
| public static final native void | flushPendingCommands()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.
|
| public static final native int | getCallingPid()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.
|
| public static final native int | getCallingUid()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.
|
| public static final UserHandle | getCallingUserHandle()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.
return new UserHandle(UserHandle.getUserId(getCallingUid()));
|
| public java.lang.String | getInterfaceDescriptor()Default implementation returns an empty interface name.
return mDescriptor;
|
| public static final native int | getThreadStrictModePolicy()Gets the current native thread-local StrictMode policy mask.
|
| private final native void | init()
|
| public boolean | isBinderAlive(){@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.
return true;
|
| public static final boolean | isProxy(IInterface iface)Returns true if the specified interface is a proxy.
return iface.asBinder() != iface;
|
| public static final native void | joinThreadPool()Add the calling thread to the IPC thread pool. This function does
not return until the current process is exiting.
|
| public void | linkToDeath(DeathRecipient recipient, int flags)Local implementation is a no-op.
|
| protected boolean | onTransact(int code, Parcel data, Parcel reply, int flags)Default implementation is a stub that returns false. You will want
to override this to do the appropriate unmarshalling of transactions.
If you want to call this, call transact().
if (code == INTERFACE_TRANSACTION) {
reply.writeString(getInterfaceDescriptor());
return true;
} else if (code == DUMP_TRANSACTION) {
ParcelFileDescriptor fd = data.readFileDescriptor();
String[] args = data.readStringArray();
if (fd != null) {
try {
dump(fd.getFileDescriptor(), args);
} finally {
try {
fd.close();
} catch (IOException e) {
// swallowed, not propagated back to the caller
}
}
}
// Write the StrictMode header.
if (reply != null) {
reply.writeNoException();
} else {
StrictMode.clearGatheredViolations();
}
return true;
}
return false;
|
| public boolean | pingBinder()Default implementation always returns true -- if you got here,
the object is alive.
return true;
|
| public IInterface | queryLocalInterface(java.lang.String descriptor)Use information supplied to attachInterface() to return the
associated IInterface if it matches the requested
descriptor.
if (mDescriptor.equals(descriptor)) {
return mOwner;
}
return null;
|
| public static final native void | restoreCallingIdentity(long token)Restore the identity of the incoming IPC on the current thread
back to a previously identity that was returned by {@link
#clearCallingIdentity}.
|
| public static void | setDumpDisabled(java.lang.String msg)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.
synchronized (Binder.class) {
sDumpDisabled = msg;
}
|
| public static final native void | setThreadStrictModePolicy(int policyMask)Sets the native thread-local StrictMode policy mask.
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.
|
| public final boolean | transact(int code, Parcel data, Parcel reply, int flags)Default implementation rewinds the parcels and calls onTransact. On
the remote side, transact calls into the binder to do the IPC.
if (false) Log.v("Binder", "Transact: " + code + " to " + this);
if (data != null) {
data.setDataPosition(0);
}
boolean r = onTransact(code, data, reply, flags);
if (reply != null) {
reply.setDataPosition(0);
}
return r;
|
| public boolean | unlinkToDeath(DeathRecipient recipient, int flags)Local implementation is a no-op.
return true;
|
