android.os.BinderProxy Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of androidstub Show documentation
Show all versions of androidstub Show documentation
provide android hidden api definition ,helper for android super framework development
/*
* Copyright (C) 2006 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package android.os;
import android.annotation.NonNull;
import java.io.FileDescriptor;
import java.lang.ref.WeakReference;
import java.util.ArrayList;
/**
* Java proxy for a native IBinder object.
* Allocated and constructed by the native javaObjectforIBinder function. Never allocated
* directly from Java code.
*
* @hide
*/
public final class BinderProxy implements IBinder {
// See android_util_Binder.cpp for the native half of this.
// Assume the process-wide default value when created
volatile boolean mWarnOnBlocking = false;
/*
* Map from longs to BinderProxy, retaining only a WeakReference to the BinderProxies.
* We roll our own only because we need to lazily remove WeakReferences during accesses
* to avoid accumulating junk WeakReference objects. WeakHashMap isn't easily usable
* because we want weak values, not keys.
* Our hash table is never resized, but the number of entries is unlimited;
* performance degrades as occupancy increases significantly past MAIN_INDEX_SIZE.
* Not thread-safe. Client ensures there's a single access at a time.
*/
private static final class ProxyMap {
private static final int LOG_MAIN_INDEX_SIZE = 8;
private static final int MAIN_INDEX_SIZE = 1 << LOG_MAIN_INDEX_SIZE;
private static final int MAIN_INDEX_MASK = MAIN_INDEX_SIZE - 1;
// Debuggable builds will throw an AssertionError if the number of map entries exceeds:
private static final int CRASH_AT_SIZE = 25_000;
/**
* We next warn when we exceed this bucket size.
*/
private int mWarnBucketSize = 20;
/**
* Increment mWarnBucketSize by WARN_INCREMENT each time we warn.
*/
private static final int WARN_INCREMENT = 10;
/**
* Hash function tailored to native pointers.
* Returns a value < MAIN_INDEX_SIZE.
*/
private static int hash(long arg) {
throw new IllegalStateException("STUB");
}
/**
* Return the total number of pairs in the map.
*/
private int size() {
throw new IllegalStateException("STUB");
}
/**
* Return the total number of pairs in the map containing values that have
* not been cleared. More expensive than the above size function.
*/
private int unclearedSize() {
throw new IllegalStateException("STUB");
}
/**
* Remove ith entry from the hash bucket indicated by hash.
*/
private void remove(int hash, int index) {
throw new IllegalStateException("STUB");
}
/**
* Look up the supplied key. If we have a non-cleared entry for it, return it.
*/
BinderProxy get(long key) {
throw new IllegalStateException("STUB");
}
private int mRandom; // A counter used to generate a "random" index. World's 2nd worst RNG.
/**
* Add the key-value pair to the map.
* Requires that the indicated key is not already in the map.
*/
void set(long key, @NonNull BinderProxy value) {
throw new IllegalStateException("STUB");
}
private InterfaceCount[] getSortedInterfaceCounts(int maxToReturn) {
throw new IllegalStateException("STUB");
}
static final int MAX_NUM_INTERFACES_TO_DUMP = 10;
/**
* Dump a histogram to the logcat. Used to diagnose abnormally large proxy maps.
*/
private void dumpProxyInterfaceCounts() {
throw new IllegalStateException("STUB");
}
/**
* Dump per uid binder proxy counts to the logcat.
*/
private void dumpPerUidProxyCounts() {
throw new IllegalStateException("STUB");
}
// Corresponding ArrayLists in the following two arrays always have the same size.
// They contain no empty entries. However WeakReferences in the values ArrayLists
// may have been cleared.
// mMainIndexKeys[i][j] corresponds to mMainIndexValues[i].get(j) .
// The values ArrayList has the proper size(), the corresponding keys array
// is always at least the same size, but may be larger.
// If either a particular keys array, or the corresponding values ArrayList
// are null, then they both are.
private final Long[][] mMainIndexKeys = new Long[MAIN_INDEX_SIZE][];
private final ArrayList>[] mMainIndexValues =
new ArrayList[MAIN_INDEX_SIZE];
}
private static final ProxyMap sProxyMap = new ProxyMap();
/**
* Simple pair-value class to store number of binder proxy interfaces live in this process.
*/
public static final class InterfaceCount {
private final String mInterfaceName;
private final int mCount;
InterfaceCount(String interfaceName, int count) {
throw new IllegalStateException("STUB");
}
@Override
public String toString() {
throw new IllegalStateException("STUB");
}
}
/**
* Get a sorted array with entries mapping proxy interface names to the number
* of live proxies with those names.
*
* @param num maximum number of proxy interface counts to return. Use
* Integer.MAX_VALUE to retrieve all
* @hide
*/
public static InterfaceCount[] getSortedInterfaceCounts(int num) {
return sProxyMap.getSortedInterfaceCounts(num);
}
/**
* Returns the number of binder proxies held in this process.
*
* @return number of binder proxies in this process
*/
public static int getProxyCount() {
synchronized (sProxyMap) {
return sProxyMap.size();
}
}
/**
* Dump proxy debug information.
*
* @hide
*/
public static void dumpProxyDebugInfo() {
throw new IllegalStateException("STUB");
}
/**
* Return a BinderProxy for IBinder.
* If we previously returned a BinderProxy bp for the same iBinder, and bp is still
* in use, then we return the same bp.
*
* @param nativeData C++ pointer to (possibly still empty) BinderProxyNativeData.
* Takes ownership of nativeData iff .mNativeData == nativeData, or if
* we exit via an exception. If neither applies, it's the callers responsibility to
* recycle nativeData.
* @param iBinder C++ pointer to IBinder. Does not take ownership of referenced object.
*/
private static BinderProxy getInstance(long nativeData, long iBinder) {
throw new IllegalStateException("STUB");
}
private BinderProxy(long nativeData) {
mNativeData = nativeData;
}
/**
* Guestimate of native memory associated with a BinderProxy.
* This includes the underlying IBinder, associated DeathRecipientList, and KeyedVector
* that points back to us. We guess high since it includes a GlobalRef, which
* may be in short supply.
*/
private static final int NATIVE_ALLOCATION_SIZE = 1000;
// Use a Holder to allow static initialization of BinderProxy in the boot image, and
// to avoid some initialization ordering issues.
private static class NoImagePreloadHolder {
public static final long sNativeFinalizer = getNativeFinalizer();
}
/**
* @return false if the hosting process is gone, otherwise whatever the remote returns
*/
public native boolean pingBinder();
/**
* @return false if the hosting process is gone
*/
public native boolean isBinderAlive();
/**
* Retrieve a local interface - always null in case of a proxy
*/
public IInterface queryLocalInterface(String descriptor) {
return null;
}
/**
* Perform a binder transaction on a proxy.
*
* @param code The action to perform. This should
* be a number between {@link #FIRST_CALL_TRANSACTION} and
* {@link #LAST_CALL_TRANSACTION}.
* @param data Marshalled data to send to the target. Must not be null.
* If you are not sending any data, you must create an empty Parcel
* that is given here.
* @param reply Marshalled data to be received from the target. May be
* null if you are not interested in the return value.
* @param flags Additional operation flags. Either 0 for a normal
* RPC, or {@link #FLAG_ONEWAY} for a one-way RPC.
* @return
* @throws RemoteException
*/
public boolean transact(int code, Parcel data, Parcel reply, int flags) throws RemoteException {
throw new IllegalStateException("STUB");
}
/* Returns the native free function */
private static native long getNativeFinalizer();
/**
* See {@link IBinder#getInterfaceDescriptor()}
*/
public native String getInterfaceDescriptor() throws RemoteException;
/**
* Native implementation of transact() for proxies
*/
public native boolean transactNative(int code, Parcel data, Parcel reply,
int flags) throws RemoteException;
/**
* See {@link IBinder#linkToDeath(DeathRecipient, int)}
*/
public native void linkToDeath(DeathRecipient recipient, int flags)
throws RemoteException;
/**
* See {@link IBinder#unlinkToDeath}
*/
public native boolean unlinkToDeath(DeathRecipient recipient, int flags);
/**
* Perform a dump on the remote object
*
* @param fd The raw file descriptor that the dump is being sent to.
* @param args additional arguments to the dump request.
* @throws RemoteException
*/
public void dump(FileDescriptor fd, String[] args) throws RemoteException {
throw new IllegalStateException("STUB");
}
/**
* Perform an asynchronous dump on the remote object
*
* @param fd The raw file descriptor that the dump is being sent to.
* @param args additional arguments to the dump request.
* @throws RemoteException
*/
public void dumpAsync(FileDescriptor fd, String[] args) throws RemoteException {
throw new IllegalStateException("STUB");
}
public void shellCommand(FileDescriptor in, FileDescriptor out, FileDescriptor err, String[] args, Object shellCallback, ResultReceiver resultReceiver) throws RemoteException {
throw new IllegalStateException("STUB");
}
/**
* See {@link IBinder#shellCommand(FileDescriptor, FileDescriptor, FileDescriptor,
* String[], ShellCallback, ResultReceiver)}
*
* @param in The raw file descriptor that an input data stream can be read from.
* @param out The raw file descriptor that normal command messages should be written to.
* @param err The raw file descriptor that command error messages should be written to.
* @param args Command-line arguments.
* @param callback Optional callback to the caller's shell to perform operations in it.
* @param resultReceiver Called when the command has finished executing, with the result code.
* @throws RemoteException
*/
public void shellCommand(FileDescriptor in, FileDescriptor out, FileDescriptor err,
String[] args, ShellCallback callback,
ResultReceiver resultReceiver) throws RemoteException {
throw new IllegalStateException("STUB");
}
private static void sendDeathNotice(DeathRecipient recipient, IBinder binderProxy) {
throw new IllegalStateException("STUB");
}
/**
* C++ pointer to BinderProxyNativeData. That consists of strong pointers to the
* native IBinder object, and a DeathRecipientList.
*/
private final long mNativeData;
}