|
|
Android example source code file (Debug.java)
This example Android source code file (Debug.java) is included in the DevDaily.com
"Java Source Code
Warehouse" project. The intent of this project is to help you "Learn
Android by Example" TM.
The Debug.java Android example source code
/*
* Copyright (C) 2007 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 com.android.internal.util.TypedProperties;
import android.util.Config;
import android.util.Log;
import java.io.FileDescriptor;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.Reader;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.lang.annotation.Target;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import org.apache.harmony.dalvik.ddmc.Chunk;
import org.apache.harmony.dalvik.ddmc.ChunkHandler;
import org.apache.harmony.dalvik.ddmc.DdmServer;
import dalvik.bytecode.Opcodes;
import dalvik.system.VMDebug;
/**
* Provides various debugging functions for Android applications, including
* tracing and allocation counts.
* <p>Logging Trace Files
* <p>Debug can create log files that give details about an application, such as
* a call stack and start/stop times for any running methods. See <a
href="{@docRoot}guide/developing/tools/traceview.html">Traceview: A Graphical Log Viewer</a> for
* information about reading trace files. To start logging trace files, call one
* of the startMethodTracing() methods. To stop tracing, call
* {@link #stopMethodTracing()}.
*/
public final class Debug
{
private static final String TAG = "Debug";
/**
* Flags for startMethodTracing(). These can be ORed together.
*
* TRACE_COUNT_ALLOCS adds the results from startAllocCounting to the
* trace key file.
*/
public static final int TRACE_COUNT_ALLOCS = VMDebug.TRACE_COUNT_ALLOCS;
/**
* Flags for printLoadedClasses(). Default behavior is to only show
* the class name.
*/
public static final int SHOW_FULL_DETAIL = 1;
public static final int SHOW_CLASSLOADER = (1 << 1);
public static final int SHOW_INITIALIZED = (1 << 2);
// set/cleared by waitForDebugger()
private static volatile boolean mWaiting = false;
private Debug() {}
/*
* How long to wait for the debugger to finish sending requests. I've
* seen this hit 800msec on the device while waiting for a response
* to travel over USB and get processed, so we take that and add
* half a second.
*/
private static final int MIN_DEBUGGER_IDLE = 1300; // msec
/* how long to sleep when polling for activity */
private static final int SPIN_DELAY = 200; // msec
/**
* Default trace file path and file
*/
private static final String DEFAULT_TRACE_PATH_PREFIX =
Environment.getExternalStorageDirectory().getPath() + "/";
private static final String DEFAULT_TRACE_BODY = "dmtrace";
private static final String DEFAULT_TRACE_EXTENSION = ".trace";
private static final String DEFAULT_TRACE_FILE_PATH =
DEFAULT_TRACE_PATH_PREFIX + DEFAULT_TRACE_BODY
+ DEFAULT_TRACE_EXTENSION;
/**
* This class is used to retrieved various statistics about the memory mappings for this
* process. The returns info broken down by dalvik, native, and other. All results are in kB.
*/
public static class MemoryInfo implements Parcelable {
/** The proportional set size for dalvik. */
public int dalvikPss;
/** The private dirty pages used by dalvik. */
public int dalvikPrivateDirty;
/** The shared dirty pages used by dalvik. */
public int dalvikSharedDirty;
/** The proportional set size for the native heap. */
public int nativePss;
/** The private dirty pages used by the native heap. */
public int nativePrivateDirty;
/** The shared dirty pages used by the native heap. */
public int nativeSharedDirty;
/** The proportional set size for everything else. */
public int otherPss;
/** The private dirty pages used by everything else. */
public int otherPrivateDirty;
/** The shared dirty pages used by everything else. */
public int otherSharedDirty;
public MemoryInfo() {
}
/**
* Return total PSS memory usage in kB.
*/
public int getTotalPss() {
return dalvikPss + nativePss + otherPss;
}
/**
* Return total private dirty memory usage in kB.
*/
public int getTotalPrivateDirty() {
return dalvikPrivateDirty + nativePrivateDirty + otherPrivateDirty;
}
/**
* Return total shared dirty memory usage in kB.
*/
public int getTotalSharedDirty() {
return dalvikSharedDirty + nativeSharedDirty + otherSharedDirty;
}
public int describeContents() {
return 0;
}
public void writeToParcel(Parcel dest, int flags) {
dest.writeInt(dalvikPss);
dest.writeInt(dalvikPrivateDirty);
dest.writeInt(dalvikSharedDirty);
dest.writeInt(nativePss);
dest.writeInt(nativePrivateDirty);
dest.writeInt(nativeSharedDirty);
dest.writeInt(otherPss);
dest.writeInt(otherPrivateDirty);
dest.writeInt(otherSharedDirty);
}
public void readFromParcel(Parcel source) {
dalvikPss = source.readInt();
dalvikPrivateDirty = source.readInt();
dalvikSharedDirty = source.readInt();
nativePss = source.readInt();
nativePrivateDirty = source.readInt();
nativeSharedDirty = source.readInt();
otherPss = source.readInt();
otherPrivateDirty = source.readInt();
otherSharedDirty = source.readInt();
}
public static final Creator<MemoryInfo> CREATOR = new Creator() {
public MemoryInfo createFromParcel(Parcel source) {
return new MemoryInfo(source);
}
public MemoryInfo[] newArray(int size) {
return new MemoryInfo[size];
}
};
private MemoryInfo(Parcel source) {
readFromParcel(source);
}
}
/**
* Wait until a debugger attaches. As soon as the debugger attaches,
* this returns, so you will need to place a breakpoint after the
* waitForDebugger() call if you want to start tracing immediately.
*/
public static void waitForDebugger() {
if (!VMDebug.isDebuggingEnabled()) {
//System.out.println("debugging not enabled, not waiting");
return;
}
if (isDebuggerConnected())
return;
// if DDMS is listening, inform them of our plight
System.out.println("Sending WAIT chunk");
byte[] data = new byte[] { 0 }; // 0 == "waiting for debugger"
Chunk waitChunk = new Chunk(ChunkHandler.type("WAIT"), data, 0, 1);
DdmServer.sendChunk(waitChunk);
mWaiting = true;
while (!isDebuggerConnected()) {
try { Thread.sleep(SPIN_DELAY); }
catch (InterruptedException ie) {}
}
mWaiting = false;
System.out.println("Debugger has connected");
/*
* There is no "ready to go" signal from the debugger, and we're
* not allowed to suspend ourselves -- the debugger expects us to
* be running happily, and gets confused if we aren't. We need to
* allow the debugger a chance to set breakpoints before we start
* running again.
*
* Sit and spin until the debugger has been idle for a short while.
*/
while (true) {
long delta = VMDebug.lastDebuggerActivity();
if (delta < 0) {
System.out.println("debugger detached?");
break;
}
if (delta < MIN_DEBUGGER_IDLE) {
System.out.println("waiting for debugger to settle...");
try { Thread.sleep(SPIN_DELAY); }
catch (InterruptedException ie) {}
} else {
System.out.println("debugger has settled (" + delta + ")");
break;
}
}
}
/**
* Returns "true" if one or more threads is waiting for a debugger
* to attach.
*/
public static boolean waitingForDebugger() {
return mWaiting;
}
/**
* Determine if a debugger is currently attached.
*/
public static boolean isDebuggerConnected() {
return VMDebug.isDebuggerConnected();
}
/**
* Returns an array of strings that identify VM features. This is
* used by DDMS to determine what sorts of operations the VM can
* perform.
*
* @hide
*/
public static String[] getVmFeatureList() {
return VMDebug.getVmFeatureList();
}
/**
* Change the JDWP port.
*
* @deprecated no longer needed or useful
*/
@Deprecated
public static void changeDebugPort(int port) {}
/**
* This is the pathname to the sysfs file that enables and disables
* tracing on the qemu emulator.
*/
private static final String SYSFS_QEMU_TRACE_STATE = "/sys/qemu_trace/state";
/**
* Enable qemu tracing. For this to work requires running everything inside
* the qemu emulator; otherwise, this method will have no effect. The trace
* file is specified on the command line when the emulator is started. For
* example, the following command line <br />
* <code>emulator -trace foo
* will start running the emulator and create a trace file named "foo". This
* method simply enables writing the trace records to the trace file.
*
* <p>
* The main differences between this and {@link #startMethodTracing()} are
* that tracing in the qemu emulator traces every cpu instruction of every
* process, including kernel code, so we have more complete information,
* including all context switches. We can also get more detailed information
* such as cache misses. The sequence of calls is determined by
* post-processing the instruction trace. The qemu tracing is also done
* without modifying the application or perturbing the timing of calls
* because no instrumentation is added to the application being traced.
* </p>
*
* <p>
* One limitation of using this method compared to using
* {@link #startMethodTracing()} on the real device is that the emulator
* does not model all of the real hardware effects such as memory and
* bus contention. The emulator also has a simple cache model and cannot
* capture all the complexities of a real cache.
* </p>
*/
public static void startNativeTracing() {
// Open the sysfs file for writing and write "1" to it.
PrintWriter outStream = null;
try {
FileOutputStream fos = new FileOutputStream(SYSFS_QEMU_TRACE_STATE);
outStream = new PrintWriter(new OutputStreamWriter(fos));
outStream.println("1");
} catch (Exception e) {
} finally {
if (outStream != null)
outStream.close();
}
VMDebug.startEmulatorTracing();
}
/**
* Stop qemu tracing. See {@link #startNativeTracing()} to start tracing.
*
* <p>Tracing can be started and stopped as many times as desired. When
* the qemu emulator itself is stopped then the buffered trace records
* are flushed and written to the trace file. In fact, it is not necessary
* to call this method at all; simply killing qemu is sufficient. But
* starting and stopping a trace is useful for examining a specific
* region of code.</p>
*/
public static void stopNativeTracing() {
VMDebug.stopEmulatorTracing();
// Open the sysfs file for writing and write "0" to it.
PrintWriter outStream = null;
try {
FileOutputStream fos = new FileOutputStream(SYSFS_QEMU_TRACE_STATE);
outStream = new PrintWriter(new OutputStreamWriter(fos));
outStream.println("0");
} catch (Exception e) {
// We could print an error message here but we probably want
// to quietly ignore errors if we are not running in the emulator.
} finally {
if (outStream != null)
outStream.close();
}
}
/**
* Enable "emulator traces", in which information about the current
* method is made available to the "emulator -trace" feature. There
* is no corresponding "disable" call -- this is intended for use by
* the framework when tracing should be turned on and left that way, so
* that traces captured with F9/F10 will include the necessary data.
*
* This puts the VM into "profile" mode, which has performance
* consequences.
*
* To temporarily enable tracing, use {@link #startNativeTracing()}.
*/
public static void enableEmulatorTraceOutput() {
VMDebug.startEmulatorTracing();
}
/**
* Start method tracing with default log name and buffer size. See <a
href="{@docRoot}guide/developing/tools/traceview.html">Traceview: A Graphical Log Viewer</a> for
* information about reading these files. Call stopMethodTracing() to stop
* tracing.
*/
public static void startMethodTracing() {
VMDebug.startMethodTracing(DEFAULT_TRACE_FILE_PATH, 0, 0);
}
/**
* Start method tracing, specifying the trace log file name. The trace
* file will be put under "/sdcard" unless an absolute path is given.
* See <a
href="{@docRoot}guide/developing/tools/traceview.html">Traceview: A Graphical Log Viewer</a> for
* information about reading trace files.
*
* @param traceName Name for the trace log file to create.
* If no name argument is given, this value defaults to "/sdcard/dmtrace.trace".
* If the files already exist, they will be truncated.
* If the trace file given does not end in ".trace", it will be appended for you.
*/
public static void startMethodTracing(String traceName) {
startMethodTracing(traceName, 0, 0);
}
/**
* Start method tracing, specifying the trace log file name and the
* buffer size. The trace files will be put under "/sdcard" unless an
* absolute path is given. See <a
href="{@docRoot}guide/developing/tools/traceview.html">Traceview: A Graphical Log Viewer</a> for
* information about reading trace files.
* @param traceName Name for the trace log file to create.
* If no name argument is given, this value defaults to "/sdcard/dmtrace.trace".
* If the files already exist, they will be truncated.
* If the trace file given does not end in ".trace", it will be appended for you.
*
* @param bufferSize The maximum amount of trace data we gather. If not given, it defaults to 8MB.
*/
public static void startMethodTracing(String traceName, int bufferSize) {
startMethodTracing(traceName, bufferSize, 0);
}
/**
* Start method tracing, specifying the trace log file name and the
* buffer size. The trace files will be put under "/sdcard" unless an
* absolute path is given. See <a
href="{@docRoot}guide/developing/tools/traceview.html">Traceview: A Graphical Log Viewer</a> for
* information about reading trace files.
*
* <p>
* When method tracing is enabled, the VM will run more slowly than
* usual, so the timings from the trace files should only be considered
* in relative terms (e.g. was run #1 faster than run #2). The times
* for native methods will not change, so don't try to use this to
* compare the performance of interpreted and native implementations of the
* same method. As an alternative, consider using "native" tracing
* in the emulator via {@link #startNativeTracing()}.
* </p>
*
* @param traceName Name for the trace log file to create.
* If no name argument is given, this value defaults to "/sdcard/dmtrace.trace".
* If the files already exist, they will be truncated.
* If the trace file given does not end in ".trace", it will be appended for you.
* @param bufferSize The maximum amount of trace data we gather. If not given, it defaults to 8MB.
*/
public static void startMethodTracing(String traceName, int bufferSize,
int flags) {
String pathName = traceName;
if (pathName.charAt(0) != '/')
pathName = DEFAULT_TRACE_PATH_PREFIX + pathName;
if (!pathName.endsWith(DEFAULT_TRACE_EXTENSION))
pathName = pathName + DEFAULT_TRACE_EXTENSION;
VMDebug.startMethodTracing(pathName, bufferSize, flags);
}
/**
* Like startMethodTracing(String, int, int), but taking an already-opened
* FileDescriptor in which the trace is written. The file name is also
* supplied simply for logging. Makes a dup of the file descriptor.
*
* Not exposed in the SDK unless we are really comfortable with supporting
* this and find it would be useful.
* @hide
*/
public static void startMethodTracing(String traceName, FileDescriptor fd,
int bufferSize, int flags) {
VMDebug.startMethodTracing(traceName, fd, bufferSize, flags);
}
/**
* Starts method tracing without a backing file. When stopMethodTracing
* is called, the result is sent directly to DDMS. (If DDMS is not
* attached when tracing ends, the profiling data will be discarded.)
*
* @hide
*/
public static void startMethodTracingDdms(int bufferSize, int flags) {
VMDebug.startMethodTracingDdms(bufferSize, flags);
}
/**
* Determine whether method tracing is currently active.
* @hide
*/
public static boolean isMethodTracingActive() {
return VMDebug.isMethodTracingActive();
}
/**
* Stop method tracing.
*/
public static void stopMethodTracing() {
VMDebug.stopMethodTracing();
}
/**
* Get an indication of thread CPU usage. The value returned
* indicates the amount of time that the current thread has spent
* executing code or waiting for certain types of I/O.
*
* The time is expressed in nanoseconds, and is only meaningful
* when compared to the result from an earlier call. Note that
* nanosecond resolution does not imply nanosecond accuracy.
*
* On system which don't support this operation, the call returns -1.
*/
public static long threadCpuTimeNanos() {
return VMDebug.threadCpuTimeNanos();
}
/**
* Count the number and aggregate size of memory allocations between
* two points.
*
* The "start" function resets the counts and enables counting. The
* "stop" function disables the counting so that the analysis code
* doesn't cause additional allocations. The "get" function returns
* the specified value.
*
* Counts are kept for the system as a whole and for each thread.
* The per-thread counts for threads other than the current thread
* are not cleared by the "reset" or "start" calls.
*/
public static void startAllocCounting() {
VMDebug.startAllocCounting();
}
public static void stopAllocCounting() {
VMDebug.stopAllocCounting();
}
public static int getGlobalAllocCount() {
return VMDebug.getAllocCount(VMDebug.KIND_GLOBAL_ALLOCATED_OBJECTS);
}
public static int getGlobalAllocSize() {
return VMDebug.getAllocCount(VMDebug.KIND_GLOBAL_ALLOCATED_BYTES);
}
public static int getGlobalFreedCount() {
return VMDebug.getAllocCount(VMDebug.KIND_GLOBAL_FREED_OBJECTS);
}
public static int getGlobalFreedSize() {
return VMDebug.getAllocCount(VMDebug.KIND_GLOBAL_FREED_BYTES);
}
public static int getGlobalClassInitCount() {
/* number of classes that have been successfully initialized */
return VMDebug.getAllocCount(VMDebug.KIND_GLOBAL_CLASS_INIT_COUNT);
}
public static int getGlobalClassInitTime() {
/* cumulative elapsed time for class initialization, in usec */
return VMDebug.getAllocCount(VMDebug.KIND_GLOBAL_CLASS_INIT_TIME);
}
public static int getGlobalExternalAllocCount() {
return VMDebug.getAllocCount(VMDebug.KIND_GLOBAL_EXT_ALLOCATED_OBJECTS);
}
public static int getGlobalExternalAllocSize() {
return VMDebug.getAllocCount(VMDebug.KIND_GLOBAL_EXT_ALLOCATED_BYTES);
}
public static int getGlobalExternalFreedCount() {
return VMDebug.getAllocCount(VMDebug.KIND_GLOBAL_EXT_FREED_OBJECTS);
}
public static int getGlobalExternalFreedSize() {
return VMDebug.getAllocCount(VMDebug.KIND_GLOBAL_EXT_FREED_BYTES);
}
public static int getGlobalGcInvocationCount() {
return VMDebug.getAllocCount(VMDebug.KIND_GLOBAL_GC_INVOCATIONS);
}
public static int getThreadAllocCount() {
return VMDebug.getAllocCount(VMDebug.KIND_THREAD_ALLOCATED_OBJECTS);
}
public static int getThreadAllocSize() {
return VMDebug.getAllocCount(VMDebug.KIND_THREAD_ALLOCATED_BYTES);
}
public static int getThreadExternalAllocCount() {
return VMDebug.getAllocCount(VMDebug.KIND_THREAD_EXT_ALLOCATED_OBJECTS);
}
public static int getThreadExternalAllocSize() {
return VMDebug.getAllocCount(VMDebug.KIND_THREAD_EXT_ALLOCATED_BYTES);
}
public static int getThreadGcInvocationCount() {
return VMDebug.getAllocCount(VMDebug.KIND_THREAD_GC_INVOCATIONS);
}
public static void resetGlobalAllocCount() {
VMDebug.resetAllocCount(VMDebug.KIND_GLOBAL_ALLOCATED_OBJECTS);
}
public static void resetGlobalAllocSize() {
VMDebug.resetAllocCount(VMDebug.KIND_GLOBAL_ALLOCATED_BYTES);
}
public static void resetGlobalFreedCount() {
VMDebug.resetAllocCount(VMDebug.KIND_GLOBAL_FREED_OBJECTS);
}
public static void resetGlobalFreedSize() {
VMDebug.resetAllocCount(VMDebug.KIND_GLOBAL_FREED_BYTES);
}
public static void resetGlobalClassInitCount() {
VMDebug.resetAllocCount(VMDebug.KIND_GLOBAL_CLASS_INIT_COUNT);
}
public static void resetGlobalClassInitTime() {
VMDebug.resetAllocCount(VMDebug.KIND_GLOBAL_CLASS_INIT_TIME);
}
public static void resetGlobalExternalAllocCount() {
VMDebug.resetAllocCount(VMDebug.KIND_GLOBAL_EXT_ALLOCATED_OBJECTS);
}
public static void resetGlobalExternalAllocSize() {
VMDebug.resetAllocCount(VMDebug.KIND_GLOBAL_EXT_ALLOCATED_BYTES);
}
public static void resetGlobalExternalFreedCount() {
VMDebug.resetAllocCount(VMDebug.KIND_GLOBAL_EXT_FREED_OBJECTS);
}
public static void resetGlobalExternalFreedSize() {
VMDebug.resetAllocCount(VMDebug.KIND_GLOBAL_EXT_FREED_BYTES);
}
public static void resetGlobalGcInvocationCount() {
VMDebug.resetAllocCount(VMDebug.KIND_GLOBAL_GC_INVOCATIONS);
}
public static void resetThreadAllocCount() {
VMDebug.resetAllocCount(VMDebug.KIND_THREAD_ALLOCATED_OBJECTS);
}
public static void resetThreadAllocSize() {
VMDebug.resetAllocCount(VMDebug.KIND_THREAD_ALLOCATED_BYTES);
}
public static void resetThreadExternalAllocCount() {
VMDebug.resetAllocCount(VMDebug.KIND_THREAD_EXT_ALLOCATED_OBJECTS);
}
public static void resetThreadExternalAllocSize() {
VMDebug.resetAllocCount(VMDebug.KIND_THREAD_EXT_ALLOCATED_BYTES);
}
public static void resetThreadGcInvocationCount() {
VMDebug.resetAllocCount(VMDebug.KIND_THREAD_GC_INVOCATIONS);
}
public static void resetAllCounts() {
VMDebug.resetAllocCount(VMDebug.KIND_ALL_COUNTS);
}
/**
* Returns the size of the native heap.
* @return The size of the native heap in bytes.
*/
public static native long getNativeHeapSize();
/**
* Returns the amount of allocated memory in the native heap.
* @return The allocated size in bytes.
*/
public static native long getNativeHeapAllocatedSize();
/**
* Returns the amount of free memory in the native heap.
* @return The freed size in bytes.
*/
public static native long getNativeHeapFreeSize();
/**
* Retrieves information about this processes memory usages. This information is broken down by
* how much is in use by dalivk, the native heap, and everything else.
*/
public static native void getMemoryInfo(MemoryInfo memoryInfo);
/**
* Note: currently only works when the requested pid has the same UID
* as the caller.
* @hide
*/
public static native void getMemoryInfo(int pid, MemoryInfo memoryInfo);
/**
* Establish an object allocation limit in the current thread. Useful
* for catching regressions in code that is expected to operate
* without causing any allocations.
*
* Pass in the maximum number of allowed allocations. Use -1 to disable
* the limit. Returns the previous limit.
*
* The preferred way to use this is:
*
* int prevLimit = -1;
* try {
* prevLimit = Debug.setAllocationLimit(0);
* ... do stuff that's not expected to allocate memory ...
* } finally {
* Debug.setAllocationLimit(prevLimit);
* }
*
* This allows limits to be nested. The try/finally ensures that the
* limit is reset if something fails.
*
* Exceeding the limit causes a dalvik.system.AllocationLimitError to
* be thrown from a memory allocation call. The limit is reset to -1
* when this happens.
*
* The feature may be disabled in the VM configuration. If so, this
* call has no effect, and always returns -1.
*/
public static int setAllocationLimit(int limit) {
return VMDebug.setAllocationLimit(limit);
}
/**
* Establish a global object allocation limit. This is similar to
* {@link #setAllocationLimit(int)} but applies to all threads in
* the VM. It will coexist peacefully with per-thread limits.
*
* [ The value of "limit" is currently restricted to 0 (no allocations
* allowed) or -1 (no global limit). This may be changed in a future
* release. ]
*/
public static int setGlobalAllocationLimit(int limit) {
if (limit != 0 && limit != -1)
throw new IllegalArgumentException("limit must be 0 or -1");
return VMDebug.setGlobalAllocationLimit(limit);
}
/**
* Dump a list of all currently loaded class to the log file.
*
* @param flags See constants above.
*/
public static void printLoadedClasses(int flags) {
VMDebug.printLoadedClasses(flags);
}
/**
* Get the number of loaded classes.
* @return the number of loaded classes.
*/
public static int getLoadedClassCount() {
return VMDebug.getLoadedClassCount();
}
/**
* Dump "hprof" data to the specified file. This will cause a GC.
*
* @param fileName Full pathname of output file (e.g. "/sdcard/dump.hprof").
* @throws UnsupportedOperationException if the VM was built without
* HPROF support.
* @throws IOException if an error occurs while opening or writing files.
*/
public static void dumpHprofData(String fileName) throws IOException {
VMDebug.dumpHprofData(fileName);
}
/**
* Collect "hprof" and send it to DDMS. This will cause a GC.
*
* @throws UnsupportedOperationException if the VM was built without
* HPROF support.
*
* @hide
*/
public static void dumpHprofDataDdms() {
VMDebug.dumpHprofDataDdms();
}
/**
* Returns the number of sent transactions from this process.
* @return The number of sent transactions or -1 if it could not read t.
*/
public static native int getBinderSentTransactions();
/**
* Returns the number of received transactions from the binder driver.
* @return The number of received transactions or -1 if it could not read the stats.
*/
public static native int getBinderReceivedTransactions();
/**
* Returns the number of active local Binder objects that exist in the
* current process.
*/
public static final native int getBinderLocalObjectCount();
/**
* Returns the number of references to remote proxy Binder objects that
* exist in the current process.
*/
public static final native int getBinderProxyObjectCount();
/**
* Returns the number of death notification links to Binder objects that
* exist in the current process.
*/
public static final native int getBinderDeathObjectCount();
/**
* Primes the register map cache.
*
* Only works for classes in the bootstrap class loader. Does not
* cause classes to be loaded if they're not already present.
*
* The classAndMethodDesc argument is a concatentation of the VM-internal
* class descriptor, method name, and method descriptor. Examples:
* Landroid/os/Looper;.loop:()V
* Landroid/app/ActivityThread;.main:([Ljava/lang/String;)V
*
* @param classAndMethodDesc the method to prepare
*
* @hide
*/
public static final boolean cacheRegisterMap(String classAndMethodDesc) {
return VMDebug.cacheRegisterMap(classAndMethodDesc);
}
/**
* Dumps the contents of VM reference tables (e.g. JNI locals and
* globals) to the log file.
*
* @hide
*/
public static final void dumpReferenceTables() {
VMDebug.dumpReferenceTables();
}
/**
* API for gathering and querying instruction counts.
*
* Example usage:
* Debug.InstructionCount icount = new Debug.InstructionCount();
* icount.resetAndStart();
* [... do lots of stuff ...]
* if (icount.collect()) {
* System.out.println("Total instructions executed: "
* + icount.globalTotal());
* System.out.println("Method invocations: "
* + icount.globalMethodInvocations());
* }
*/
public static class InstructionCount {
private static final int NUM_INSTR = 256;
private int[] mCounts;
public InstructionCount() {
mCounts = new int[NUM_INSTR];
}
/**
* Reset counters and ensure counts are running. Counts may
* have already been running.
*
* @return true if counting was started
*/
public boolean resetAndStart() {
try {
VMDebug.startInstructionCounting();
VMDebug.resetInstructionCount();
} catch (UnsupportedOperationException uoe) {
return false;
}
return true;
}
/**
* Collect instruction counts. May or may not stop the
* counting process.
*/
public boolean collect() {
try {
VMDebug.stopInstructionCounting();
VMDebug.getInstructionCount(mCounts);
} catch (UnsupportedOperationException uoe) {
return false;
}
return true;
}
/**
* Return the total number of instructions executed globally (i.e. in
* all threads).
*/
public int globalTotal() {
int count = 0;
for (int i = 0; i < NUM_INSTR; i++)
count += mCounts[i];
return count;
}
/**
* Return the total number of method-invocation instructions
* executed globally.
*/
public int globalMethodInvocations() {
int count = 0;
//count += mCounts[Opcodes.OP_EXECUTE_INLINE];
count += mCounts[Opcodes.OP_INVOKE_VIRTUAL];
count += mCounts[Opcodes.OP_INVOKE_SUPER];
count += mCounts[Opcodes.OP_INVOKE_DIRECT];
count += mCounts[Opcodes.OP_INVOKE_STATIC];
count += mCounts[Opcodes.OP_INVOKE_INTERFACE];
count += mCounts[Opcodes.OP_INVOKE_VIRTUAL_RANGE];
count += mCounts[Opcodes.OP_INVOKE_SUPER_RANGE];
count += mCounts[Opcodes.OP_INVOKE_DIRECT_RANGE];
count += mCounts[Opcodes.OP_INVOKE_STATIC_RANGE];
count += mCounts[Opcodes.OP_INVOKE_INTERFACE_RANGE];
//count += mCounts[Opcodes.OP_INVOKE_DIRECT_EMPTY];
count += mCounts[Opcodes.OP_INVOKE_VIRTUAL_QUICK];
count += mCounts[Opcodes.OP_INVOKE_VIRTUAL_QUICK_RANGE];
count += mCounts[Opcodes.OP_INVOKE_SUPER_QUICK];
count += mCounts[Opcodes.OP_INVOKE_SUPER_QUICK_RANGE];
return count;
}
}
/**
* A Map of typed debug properties.
*/
private static final TypedProperties debugProperties;
/*
* Load the debug properties from the standard files into debugProperties.
*/
static {
if (Config.DEBUG) {
final String TAG = "DebugProperties";
final String[] files = { "/system/debug.prop", "/debug.prop", "/data/debug.prop" };
final TypedProperties tp = new TypedProperties();
// Read the properties from each of the files, if present.
for (String file : files) {
Reader r;
try {
r = new FileReader(file);
} catch (FileNotFoundException ex) {
// It's ok if a file is missing.
continue;
}
try {
tp.load(r);
} catch (Exception ex) {
throw new RuntimeException("Problem loading " + file, ex);
} finally {
try {
r.close();
} catch (IOException ex) {
// Ignore this error.
}
}
}
debugProperties = tp.isEmpty() ? null : tp;
} else {
debugProperties = null;
}
}
/**
* Returns true if the type of the field matches the specified class.
* Handles the case where the class is, e.g., java.lang.Boolean, but
* the field is of the primitive "boolean" type. Also handles all of
* the java.lang.Number subclasses.
*/
private static boolean fieldTypeMatches(Field field, Class<?> cl) {
Class<?> fieldClass = field.getType();
if (fieldClass == cl) {
return true;
}
Field primitiveTypeField;
try {
/* All of the classes we care about (Boolean, Integer, etc.)
* have a Class field called "TYPE" that points to the corresponding
* primitive class.
*/
primitiveTypeField = cl.getField("TYPE");
} catch (NoSuchFieldException ex) {
return false;
}
try {
return fieldClass == (Class<?>) primitiveTypeField.get(null);
} catch (IllegalAccessException ex) {
return false;
}
}
/**
* Looks up the property that corresponds to the field, and sets the field's value
* if the types match.
*/
private static void modifyFieldIfSet(final Field field, final TypedProperties properties,
final String propertyName) {
if (field.getType() == java.lang.String.class) {
int stringInfo = properties.getStringInfo(propertyName);
switch (stringInfo) {
case TypedProperties.STRING_SET:
// Handle as usual below.
break;
case TypedProperties.STRING_NULL:
try {
field.set(null, null); // null object for static fields; null string
} catch (IllegalAccessException ex) {
throw new IllegalArgumentException(
"Cannot set field for " + propertyName, ex);
}
return;
case TypedProperties.STRING_NOT_SET:
return;
case TypedProperties.STRING_TYPE_MISMATCH:
throw new IllegalArgumentException(
"Type of " + propertyName + " " +
" does not match field type (" + field.getType() + ")");
default:
throw new IllegalStateException(
"Unexpected getStringInfo(" + propertyName + ") return value " +
stringInfo);
}
}
Object value = properties.get(propertyName);
if (value != null) {
if (!fieldTypeMatches(field, value.getClass())) {
throw new IllegalArgumentException(
"Type of " + propertyName + " (" + value.getClass() + ") " +
" does not match field type (" + field.getType() + ")");
}
try {
field.set(null, value); // null object for static fields
} catch (IllegalAccessException ex) {
throw new IllegalArgumentException(
"Cannot set field for " + propertyName, ex);
}
}
}
/**
* Equivalent to <code>setFieldsOn(cl, false).
*
* @see #setFieldsOn(Class, boolean)
*
* @hide
*/
public static void setFieldsOn(Class<?> cl) {
setFieldsOn(cl, false);
}
/**
* Reflectively sets static fields of a class based on internal debugging
* properties. This method is a no-op if android.util.Config.DEBUG is
* false.
* <p>
* <strong>NOTE TO APPLICATION DEVELOPERS: Config.DEBUG will
* always be false in release builds. This API is typically only useful
* for platform developers.
* </p>
* Class setup: define a class whose only fields are non-final, static
* primitive types (except for "char") or Strings. In a static block
* after the field definitions/initializations, pass the class to
* this method, Debug.setFieldsOn(). Example:
* <pre>
* package com.example;
*
* import android.os.Debug;
*
* public class MyDebugVars {
* public static String s = "a string";
* public static String s2 = "second string";
* public static String ns = null;
* public static boolean b = false;
* public static int i = 5;
* @Debug.DebugProperty
* public static float f = 0.1f;
* @@Debug.DebugProperty
* public static double d = 0.5d;
*
* // This MUST appear AFTER all fields are defined and initialized!
* static {
* // Sets all the fields
* Debug.setFieldsOn(MyDebugVars.class);
*
* // Sets only the fields annotated with @Debug.DebugProperty
* // Debug.setFieldsOn(MyDebugVars.class, true);
* }
* }
* </pre>
* setFieldsOn() may override the value of any field in the class based
* on internal properties that are fixed at boot time.
* <p>
* These properties are only set during platform debugging, and are not
* meant to be used as a general-purpose properties store.
*
* {@hide}
*
* @param cl The class to (possibly) modify
* @param partial If false, sets all static fields, otherwise, only set
* fields with the {@link android.os.Debug.DebugProperty}
* annotation
* @throws IllegalArgumentException if any fields are final or non-static,
* or if the type of the field does not match the type of
* the internal debugging property value.
*/
public static void setFieldsOn(Class<?> cl, boolean partial) {
if (Config.DEBUG) {
if (debugProperties != null) {
/* Only look for fields declared directly by the class,
* so we don't mysteriously change static fields in superclasses.
*/
for (Field field : cl.getDeclaredFields()) {
if (!partial || field.getAnnotation(DebugProperty.class) != null) {
final String propertyName = cl.getName() + "." + field.getName();
boolean isStatic = Modifier.isStatic(field.getModifiers());
boolean isFinal = Modifier.isFinal(field.getModifiers());
if (!isStatic || isFinal) {
throw new IllegalArgumentException(propertyName +
" must be static and non-final");
}
modifyFieldIfSet(field, debugProperties, propertyName);
}
}
}
} else {
Log.wtf(TAG,
"setFieldsOn(" + (cl == null ? "null" : cl.getName()) +
") called in non-DEBUG build");
}
}
/**
* Annotation to put on fields you want to set with
* {@link Debug#setFieldsOn(Class, boolean)}.
*
* @hide
*/
@Target({ ElementType.FIELD })
@Retention(RetentionPolicy.RUNTIME)
public @interface DebugProperty {
}
/**
* Get a debugging dump of a system service by name.
*
* <p>Most services require the caller to hold android.permission.DUMP.
*
* @param name of the service to dump
* @param fd to write dump output to (usually an output log file)
* @param args to pass to the service's dump method, may be null
* @return true if the service was dumped successfully, false if
* the service could not be found or had an error while dumping
*/
public static boolean dumpService(String name, FileDescriptor fd, String[] args) {
IBinder service = ServiceManager.getService(name);
if (service == null) {
Log.e(TAG, "Can't find service to dump: " + name);
return false;
}
try {
service.dump(fd, args);
return true;
} catch (RemoteException e) {
Log.e(TAG, "Can't dump service: " + name, e);
return false;
}
}
}
Other Android examples (source code examples)
Here is a short list of links related to this Android Debug.java source code file:
|
The search page
Other Android source code examples at this package level
Click here to learn more about this project
