| 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;
|
| public static final native long | clearCallingIdentity()Reset the identity of the incoming IPC to the local process. 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 PrintWriter(fout);
try {
dump(fd, pw, args);
} 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.
|
| private boolean | execTransact(int code, int dataObj, int 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;
try {
res = onTransact(code, data, reply, flags);
} catch (RemoteException e) {
reply.writeException(e);
res = true;
} catch (RuntimeException e) {
reply.writeException(e);
res = true;
}
reply.recycle();
data.recycle();
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 ID of the user 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 java.lang.String | getInterfaceDescriptor()Default implementation returns an empty interface name.
return mDescriptor;
|
| 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 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) {
}
}
}
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 back to a previously identity
that was returned by {@link #clearCallingIdentity}.
|
| 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 (Config.LOGV) 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;
|
