Debug

SHOW_CLASSLOADER

int SHOW_CLASSLOADER

Constant Value: 2 (0x00000002)

SHOW_FULL_DETAIL

int SHOW_FULL_DETAIL

Flags for printLoadedClasses(). Default behavior is to only show the class name.

Constant Value: 1 (0x00000001)

SHOW_INITIALIZED

int SHOW_INITIALIZED

Constant Value: 4 (0x00000004)

TRACE_COUNT_ALLOCS

int TRACE_COUNT_ALLOCS

This constant was deprecated in API level 23.
Accurate counting is a burden on the runtime and may be removed.

Flags for startMethodTracing(). These can be ORed together. TRACE_COUNT_ALLOCS adds the results from startAllocCounting to the trace key file.

Constant Value: 1 (0x00000001)

changeDebugPort

void changeDebugPort (int port)

This method was deprecated in API level 3.
no longer needed or useful

Change the JDWP port.

dumpHprofData

void dumpHprofData (String fileName)

Dump "hprof" data to the specified file. This may cause a GC.

dumpService

boolean dumpService (String name, 
                FileDescriptor fd, 
                String[] args)

Get a debugging dump of a system service by name.

Most services require the caller to hold android.permission.DUMP.

enableEmulatorTraceOutput

void enableEmulatorTraceOutput ()

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 startNativeTracing().

getBinderDeathObjectCount

int getBinderDeathObjectCount ()

Returns the number of death notification links to Binder objects that exist in the current process.

getBinderLocalObjectCount

int getBinderLocalObjectCount ()

Returns the number of active local Binder objects that exist in the current process.

getBinderProxyObjectCount

int getBinderProxyObjectCount ()

Returns the number of references to remote proxy Binder objects that exist in the current process.

getBinderReceivedTransactions

int getBinderReceivedTransactions ()

Returns the number of received transactions from the binder driver.

getBinderSentTransactions

int getBinderSentTransactions ()

Returns the number of sent transactions from this process.

getGlobalAllocCount

int getGlobalAllocCount ()

This method was deprecated in API level 23.
Accurate counting is a burden on the runtime and may be removed.

Returns the global count of objects allocated by the runtime between a start and stop.

getGlobalAllocSize

int getGlobalAllocSize ()

This method was deprecated in API level 23.
Accurate counting is a burden on the runtime and may be removed.

Returns the global size, in bytes, of objects allocated by the runtime between a start and stop.

getGlobalClassInitCount

int getGlobalClassInitCount ()

This method was deprecated in API level 23.
Accurate counting is a burden on the runtime and may be removed.

Returns the number of classes successfully initialized (ie those that executed without throwing an exception) between a start and stop.

getGlobalClassInitTime

int getGlobalClassInitTime ()

This method was deprecated in API level 23.
Accurate counting is a burden on the runtime and may be removed.

Returns the time spent successfully initializing classes between a start and stop.

getGlobalExternalAllocCount

int getGlobalExternalAllocCount ()

This method was deprecated in API level 11.
This method is now obsolete.

This method exists for compatibility and always returns 0.

getGlobalExternalAllocSize

int getGlobalExternalAllocSize ()

This method was deprecated in API level 11.
This method is now obsolete.

This method exists for compatibility and always returns 0.

getGlobalExternalFreedCount

int getGlobalExternalFreedCount ()

This method was deprecated in API level 11.
This method is now obsolete.

This method exists for compatibility and always returns 0.

getGlobalExternalFreedSize

int getGlobalExternalFreedSize ()

This method was deprecated in API level 11.
This method is now obsolete.

This method exists for compatibility and has no effect.

getGlobalFreedCount

int getGlobalFreedCount ()

This method was deprecated in API level 23.
Accurate counting is a burden on the runtime and may be removed.

Returns the global count of objects freed by the runtime between a start and stop.

getGlobalFreedSize

int getGlobalFreedSize ()

This method was deprecated in API level 23.
Accurate counting is a burden on the runtime and may be removed.

Returns the global size, in bytes, of objects freed by the runtime between a start and stop.

getGlobalGcInvocationCount

int getGlobalGcInvocationCount ()

This method was deprecated in API level 23.
Accurate counting is a burden on the runtime and may be removed.

Returns the number of non-concurrent GC invocations between a start and stop.

getLoadedClassCount

int getLoadedClassCount ()

Get the number of loaded classes.

getMemoryInfo

void getMemoryInfo (Debug.MemoryInfo memoryInfo)

Retrieves information about this processes memory usages. This information is broken down by how much is in use by dalvik, the native heap, and everything else.

Note: this method directly retrieves memory information for the give process from low-level data available to it. It may not be able to retrieve information about some protected allocations, such as graphics. If you want to be sure you can see all information about allocations by the process, use instead getProcessMemoryInfo(int[]).

getNativeHeapAllocatedSize

long getNativeHeapAllocatedSize ()

Returns the amount of allocated memory in the native heap.

getNativeHeapFreeSize

long getNativeHeapFreeSize ()

Returns the amount of free memory in the native heap.

getNativeHeapSize

long getNativeHeapSize ()

Returns the size of the native heap.

getPss

long getPss ()

Retrieves the PSS memory used by the process as given by the smaps.

getRuntimeStat

String getRuntimeStat (String statName)

Returns the value of a particular runtime statistic or null if no such runtime statistic exists.

The following table lists the runtime statistics that the runtime supports. Note runtime statistics may be added or removed in a future API level.

getRuntimeStats

Map<String, String> getRuntimeStats ()

Returns a map of the names/values of the runtime statistics that getRuntimeStat(String) supports.

getThreadAllocCount

int getThreadAllocCount ()

This method was deprecated in API level 23.
Accurate counting is a burden on the runtime and may be removed.

Returns the thread-local count of objects allocated by the runtime between a start and stop.

getThreadAllocSize

int getThreadAllocSize ()

This method was deprecated in API level 23.
Accurate counting is a burden on the runtime and may be removed.

Returns the thread-local size of objects allocated by the runtime between a start and stop.

getThreadExternalAllocCount

int getThreadExternalAllocCount ()

This method was deprecated in API level 11.
This method is now obsolete.

This method exists for compatibility and has no effect.

getThreadExternalAllocSize

int getThreadExternalAllocSize ()

This method was deprecated in API level 11.
This method is now obsolete.

This method exists for compatibility and has no effect.

getThreadGcInvocationCount

int getThreadGcInvocationCount ()

This method was deprecated in API level 23.
Accurate counting is a burden on the runtime and may be removed.

Returns the number of thread-local non-concurrent GC invocations between a start and stop.

isDebuggerConnected

boolean isDebuggerConnected ()

Determine if a debugger is currently attached.

printLoadedClasses

void printLoadedClasses (int flags)

Dump a list of all currently loaded class to the log file.

resetAllCounts

void resetAllCounts ()

This method was deprecated in API level 23.
Accurate counting is a burden on the runtime and may be removed.

Clears all the global and thread-local memory allocation counters.

resetGlobalAllocCount

void resetGlobalAllocCount ()

This method was deprecated in API level 23.
Accurate counting is a burden on the runtime and may be removed.

Clears the global count of objects allocated.

resetGlobalAllocSize

void resetGlobalAllocSize ()

This method was deprecated in API level 23.
Accurate counting is a burden on the runtime and may be removed.

Clears the global size of objects allocated.

resetGlobalClassInitCount

void resetGlobalClassInitCount ()

This method was deprecated in API level 23.
Accurate counting is a burden on the runtime and may be removed.

Clears the count of classes initialized.

resetGlobalClassInitTime

void resetGlobalClassInitTime ()

This method was deprecated in API level 23.
Accurate counting is a burden on the runtime and may be removed.

Clears the count of time spent initializing classes.

resetGlobalExternalAllocCount

void resetGlobalExternalAllocCount ()

This method was deprecated in API level 11.
This method is now obsolete.

This method exists for compatibility and has no effect.

resetGlobalExternalAllocSize

void resetGlobalExternalAllocSize ()

This method was deprecated in API level 11.
This method is now obsolete.

This method exists for compatibility and has no effect.

resetGlobalExternalFreedCount

void resetGlobalExternalFreedCount ()

This method was deprecated in API level 11.
This method is now obsolete.

This method exists for compatibility and has no effect.

resetGlobalExternalFreedSize

void resetGlobalExternalFreedSize ()

This method was deprecated in API level 11.
This method is now obsolete.

This method exists for compatibility and has no effect.

resetGlobalFreedCount

void resetGlobalFreedCount ()

This method was deprecated in API level 23.
Accurate counting is a burden on the runtime and may be removed.

Clears the global count of objects freed.

resetGlobalFreedSize

void resetGlobalFreedSize ()

This method was deprecated in API level 23.
Accurate counting is a burden on the runtime and may be removed.

Clears the global size of objects freed.

resetGlobalGcInvocationCount

void resetGlobalGcInvocationCount ()

This method was deprecated in API level 23.
Accurate counting is a burden on the runtime and may be removed.

Clears the count of non-concurrent GC invocations.

resetThreadAllocCount

void resetThreadAllocCount ()

This method was deprecated in API level 23.
Accurate counting is a burden on the runtime and may be removed.

Clears the thread-local count of objects allocated.

resetThreadAllocSize

void resetThreadAllocSize ()

This method was deprecated in API level 23.
Accurate counting is a burden on the runtime and may be removed.

Clears the thread-local count of objects allocated.

resetThreadExternalAllocCount

void resetThreadExternalAllocCount ()

This method was deprecated in API level 11.
This method is now obsolete.

This method exists for compatibility and has no effect.

resetThreadExternalAllocSize

void resetThreadExternalAllocSize ()

This method was deprecated in API level 11.
This method is now obsolete.

This method exists for compatibility and has no effect.

resetThreadGcInvocationCount

void resetThreadGcInvocationCount ()

This method was deprecated in API level 23.
Accurate counting is a burden on the runtime and may be removed.

Clears the thread-local count of non-concurrent GC invocations.

setAllocationLimit

int setAllocationLimit (int limit)

This method was deprecated in API level 11.
This method is now obsolete.

Establish an object allocation limit in the current thread. This feature was never enabled in release builds. The allocation limits feature was removed in Honeycomb. This method exists for compatibility and always returns -1 and has no effect.

setGlobalAllocationLimit

int setGlobalAllocationLimit (int limit)

This method was deprecated in API level 11.
This method is now obsolete.

Establish a global object allocation limit. This feature was never enabled in release builds. The allocation limits feature was removed in Honeycomb. This method exists for compatibility and always returns -1 and has no effect.

startAllocCounting

void startAllocCounting ()

This method was deprecated in API level 18.
Accurate counting is a burden on the runtime and may be removed.

Start counting the number and aggregate size of memory allocations.

The start method resets the counts and enables counting. The stop method disables the counting so that the analysis code doesn't cause additional allocations. The various get methods return the specified value. And the various reset methods reset the specified count.

Counts are kept for the system as a whole (global) and for each thread. The per-thread counts for threads other than the current thread are not cleared by the "reset" or "start" calls.

startMethodTracing

void startMethodTracing ()

Start method tracing with default log name and buffer size.

By default, the trace file is called "dmtrace.trace" and it's placed under your package-specific directory on primary shared/external storage, as returned by getExternalFilesDir(String).

See Traceview: A Graphical Log Viewer for information about reading trace files.

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 sampling-based method tracing via startMethodTracingSampling(String, int, int) or "native" tracing in the emulator via startNativeTracing().

startMethodTracing

void startMethodTracing (String tracePath, 
                int bufferSize, 
                int flags)

Start method tracing, specifying the trace log file name, the buffer size, and flags.

When a relative file path is given, the trace file will be placed under your package-specific directory on primary shared/external storage, as returned by getExternalFilesDir(String).

See Traceview: A Graphical Log Viewer for information about reading trace files.

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 sampling-based method tracing via startMethodTracingSampling(String, int, int) or "native" tracing in the emulator via startNativeTracing().

startMethodTracing

void startMethodTracing (String tracePath)

Start method tracing, specifying the trace log file path.

When a relative file path is given, the trace file will be placed under your package-specific directory on primary shared/external storage, as returned by getExternalFilesDir(String).

See Traceview: A Graphical Log Viewer for information about reading trace files.

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 sampling-based method tracing via startMethodTracingSampling(String, int, int) or "native" tracing in the emulator via startNativeTracing().

startMethodTracing

void startMethodTracing (String tracePath, 
                int bufferSize)

Start method tracing, specifying the trace log file name and the buffer size.

When a relative file path is given, the trace file will be placed under your package-specific directory on primary shared/external storage, as returned by getExternalFilesDir(String).

See Traceview: A Graphical Log Viewer for information about reading trace files.

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 sampling-based method tracing via startMethodTracingSampling(String, int, int) or "native" tracing in the emulator via startNativeTracing().

startMethodTracingSampling

void startMethodTracingSampling (String tracePath, 
                int bufferSize, 
                int intervalUs)

Start sampling-based method tracing, specifying the trace log file name, the buffer size, and the sampling interval.

When a relative file path is given, the trace file will be placed under your package-specific directory on primary shared/external storage, as returned by getExternalFilesDir(String).

See Traceview: A Graphical Log Viewer for information about reading trace files.

startNativeTracing

void startNativeTracing ()

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
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.

The main differences between this and 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.

One limitation of using this method compared to using 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.

stopAllocCounting

void stopAllocCounting ()

This method was deprecated in API level 18.
Accurate counting is a burden on the runtime and may be removed.

Stop counting the number and aggregate size of memory allocations.

stopMethodTracing

void stopMethodTracing ()

Stop method tracing.

stopNativeTracing

void stopNativeTracing ()

Stop qemu tracing. See startNativeTracing() to start tracing.

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.

threadCpuTimeNanos

long threadCpuTimeNanos ()

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.

waitForDebugger

void waitForDebugger ()

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.

waitingForDebugger

boolean waitingForDebugger ()

Returns "true" if one or more threads is waiting for a debugger to attach.