IT. Expert System.

Android Reference

Debug


android.os

Class Debug



  • public final class Debug
    extends Object
    Provides various debugging functions for Android applications, including tracing and allocation counts.

    Logging Trace Files

    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 Traceview: A Graphical Log Viewer for information about reading trace files. To start logging trace files, call one of the startMethodTracing() methods. To stop tracing, call stopMethodTracing().

    • Field Detail

      • TRACE_COUNT_ALLOCS

        public static final int TRACE_COUNT_ALLOCS
        Flags for startMethodTracing(). These can be ORed together. TRACE_COUNT_ALLOCS adds the results from startAllocCounting to the trace key file.
      • SHOW_FULL_DETAIL

        public static final int SHOW_FULL_DETAIL
        Flags for printLoadedClasses(). Default behavior is to only show the class name.
        See Also:
        Constant Field Values
    • Method Detail

      • waitForDebugger

        public static 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

        public static boolean waitingForDebugger()
        Returns "true" if one or more threads is waiting for a debugger to attach.
      • isDebuggerConnected

        public static boolean isDebuggerConnected()
        Determine if a debugger is currently attached.
      • getVmFeatureList

        public static String[] getVmFeatureList()
        Returns an array of strings that identify VM features. This is used by DDMS to determine what sorts of operations the VM can perform.
      • changeDebugPort

        @Deprecated
        public static void changeDebugPort(int port)
        Deprecated. no longer needed or useful
        Change the JDWP port.
      • startNativeTracing

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

      • stopNativeTracing

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

      • enableEmulatorTraceOutput

        public static 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().
      • startMethodTracing

        public static void startMethodTracing()
        Start method tracing with default log name and buffer size. See Traceview: A Graphical Log Viewer for information about reading these files. Call stopMethodTracing() to stop tracing.
      • startMethodTracing

        public static void startMethodTracing(String traceName)
        Start method tracing, specifying the trace log file name. The trace file will be put under "/sdcard" unless an absolute path is given. See Traceview: A Graphical Log Viewer for information about reading trace files.
        Parameters:
        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.
      • startMethodTracing

        public static void startMethodTracing(String traceName,
                              int bufferSize)
        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 Traceview: A Graphical Log Viewer for information about reading trace files.
        Parameters:
        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.
        bufferSize - The maximum amount of trace data we gather. If not given, it defaults to 8MB.
      • startMethodTracing

        public static void startMethodTracing(String traceName,
                              int bufferSize,
                              int flags)
        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 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 "native" tracing in the emulator via startNativeTracing().

        Parameters:
        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.
        bufferSize - The maximum amount of trace data we gather. If not given, it defaults to 8MB.
      • startMethodTracing

        public static void startMethodTracing(String traceName,
                              FileDescriptor fd,
                              int bufferSize,
                              int 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.
      • startMethodTracingDdms

        public static void startMethodTracingDdms(int bufferSize,
                                  int 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.)
      • isMethodTracingActive

        public static boolean isMethodTracingActive()
        Determine whether method tracing is currently active.
      • stopMethodTracing

        public static void stopMethodTracing()
        Stop method tracing.
      • threadCpuTimeNanos

        public static 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.
      • startAllocCounting

        public static void startAllocCounting()
        Start counting the number and aggregate size of memory allocations.

        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 various get functions return the specified value. And the various reset functions reset the specified count.

        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.

      • stopAllocCounting

        public static void stopAllocCounting()
        Stop counting the number and aggregate size of memory allocations.
        See Also:
        startAllocCounting()
      • getGlobalAllocCount

        public static int getGlobalAllocCount()
      • getGlobalAllocSize

        public static int getGlobalAllocSize()
      • getGlobalFreedCount

        public static int getGlobalFreedCount()
      • getGlobalFreedSize

        public static int getGlobalFreedSize()
      • getGlobalClassInitCount

        public static int getGlobalClassInitCount()
      • getGlobalClassInitTime

        public static int getGlobalClassInitTime()
      • getGlobalExternalAllocCount

        @Deprecated
        public static int getGlobalExternalAllocCount()
        Deprecated. This method is now obsolete.
        Returns the global count of external allocation requests. The external allocation tracking feature was removed in Honeycomb. This method exists for compatibility and always returns 0.
      • getGlobalExternalAllocSize

        @Deprecated
        public static int getGlobalExternalAllocSize()
        Deprecated. This method is now obsolete.
        Returns the global count of bytes externally allocated. The external allocation tracking feature was removed in Honeycomb. This method exists for compatibility and always returns 0.
      • getGlobalExternalFreedCount

        @Deprecated
        public static int getGlobalExternalFreedCount()
        Deprecated. This method is now obsolete.
        Returns the global count of freed external allocation requests. The external allocation tracking feature was removed in Honeycomb. This method exists for compatibility and always returns 0.
      • getGlobalExternalFreedSize

        @Deprecated
        public static int getGlobalExternalFreedSize()
        Deprecated. This method is now obsolete.
        Returns the global count of freed bytes from external allocation requests. The external allocation tracking feature was removed in Honeycomb. This method exists for compatibility and always returns 0.
      • getGlobalGcInvocationCount

        public static int getGlobalGcInvocationCount()
      • getThreadAllocCount

        public static int getThreadAllocCount()
      • getThreadAllocSize

        public static int getThreadAllocSize()
      • getThreadExternalAllocCount

        @Deprecated
        public static int getThreadExternalAllocCount()
        Deprecated. This method is now obsolete.
        Returns the count of external allocation requests made by the current thread. The external allocation tracking feature was removed in Honeycomb. This method exists for compatibility and always returns 0.
      • getThreadExternalAllocSize

        @Deprecated
        public static int getThreadExternalAllocSize()
        Deprecated. This method is now obsolete.
        Returns the global count of bytes externally allocated. The external allocation tracking feature was removed in Honeycomb. This method exists for compatibility and always returns 0.
      • getThreadGcInvocationCount

        public static int getThreadGcInvocationCount()
      • resetGlobalAllocCount

        public static void resetGlobalAllocCount()
      • resetGlobalAllocSize

        public static void resetGlobalAllocSize()
      • resetGlobalFreedCount

        public static void resetGlobalFreedCount()
      • resetGlobalFreedSize

        public static void resetGlobalFreedSize()
      • resetGlobalClassInitCount

        public static void resetGlobalClassInitCount()
      • resetGlobalClassInitTime

        public static void resetGlobalClassInitTime()
      • resetGlobalExternalAllocCount

        @Deprecated
        public static void resetGlobalExternalAllocCount()
        Deprecated. This method is now obsolete.
        Resets the global count of external allocation requests. The external allocation tracking feature was removed in Honeycomb. This method exists for compatibility and has no effect.
      • resetGlobalExternalAllocSize

        @Deprecated
        public static void resetGlobalExternalAllocSize()
        Deprecated. This method is now obsolete.
        Resets the global count of bytes externally allocated. The external allocation tracking feature was removed in Honeycomb. This method exists for compatibility and has no effect.
      • resetGlobalExternalFreedCount

        @Deprecated
        public static void resetGlobalExternalFreedCount()
        Deprecated. This method is now obsolete.
        Resets the global count of freed external allocations. The external allocation tracking feature was removed in Honeycomb. This method exists for compatibility and has no effect.
      • resetGlobalExternalFreedSize

        @Deprecated
        public static void resetGlobalExternalFreedSize()
        Deprecated. This method is now obsolete.
        Resets the global count counter of freed bytes from external allocations. The external allocation tracking feature was removed in Honeycomb. This method exists for compatibility and has no effect.
      • resetGlobalGcInvocationCount

        public static void resetGlobalGcInvocationCount()
      • resetThreadAllocCount

        public static void resetThreadAllocCount()
      • resetThreadAllocSize

        public static void resetThreadAllocSize()
      • resetThreadExternalAllocCount

        @Deprecated
        public static void resetThreadExternalAllocCount()
        Deprecated. This method is now obsolete.
        Resets the count of external allocation requests made by the current thread. The external allocation tracking feature was removed in Honeycomb. This method exists for compatibility and has no effect.
      • resetThreadExternalAllocSize

        @Deprecated
        public static void resetThreadExternalAllocSize()
        Deprecated. This method is now obsolete.
        Resets the count of bytes externally allocated by the current thread. The external allocation tracking feature was removed in Honeycomb. This method exists for compatibility and has no effect.
      • resetThreadGcInvocationCount

        public static void resetThreadGcInvocationCount()
      • resetAllCounts

        public static void resetAllCounts()
      • getNativeHeapSize

        public static long getNativeHeapSize()
        Returns the size of the native heap.
        Returns:
        The size of the native heap in bytes.
      • getNativeHeapAllocatedSize

        public static long getNativeHeapAllocatedSize()
        Returns the amount of allocated memory in the native heap.
        Returns:
        The allocated size in bytes.
      • getNativeHeapFreeSize

        public static long getNativeHeapFreeSize()
        Returns the amount of free memory in the native heap.
        Returns:
        The freed size in bytes.
      • getMemoryInfo

        public static void getMemoryInfo(Debug.MemoryInfo memoryInfo)
        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.
      • getMemoryInfo

        public static void getMemoryInfo(int pid,
                         Debug.MemoryInfo memoryInfo)
        Note: currently only works when the requested pid has the same UID as the caller.
      • getPss

        public static long getPss()
        Retrieves the PSS memory used by the process as given by the smaps.
      • getPss

        public static long getPss(int pid)
        Retrieves the PSS memory used by the process as given by the smaps. @hide
      • setAllocationLimit

        @Deprecated
        public static int setAllocationLimit(int limit)
        Deprecated. 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

        @Deprecated
        public static int setGlobalAllocationLimit(int limit)
        Deprecated. 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.
      • printLoadedClasses

        public static void printLoadedClasses(int flags)
        Dump a list of all currently loaded class to the log file.
        Parameters:
        flags - See constants above.
      • getLoadedClassCount

        public static int getLoadedClassCount()
        Get the number of loaded classes.
        Returns:
        the number of loaded classes.
      • dumpHprofData

        public static void dumpHprofData(String fileName)
                                  throws IOException
        Dump "hprof" data to the specified file. This may cause a GC.
        Parameters:
        fileName - Full pathname of output file (e.g. "/sdcard/dump.hprof").
        Throws:
        UnsupportedOperationException - if the VM was built without HPROF support.
        IOException - if an error occurs while opening or writing files.
      • dumpHprofData

        public static void dumpHprofData(String fileName,
                         FileDescriptor fd)
                                  throws IOException
        Like dumpHprofData(String), but takes an already-opened FileDescriptor to which the trace is written. The file name is also supplied simply for logging. Makes a dup of the file descriptor. Primarily for use by the "am" shell command.
        Throws:
        IOException
      • dumpHprofDataDdms

        public static void dumpHprofDataDdms()
        Collect "hprof" and send it to DDMS. This may cause a GC.
        Throws:
        UnsupportedOperationException - if the VM was built without HPROF support.
      • dumpNativeHeap

        public static void dumpNativeHeap(FileDescriptor fd)
        Writes native heap data to the specified file descriptor.
      • countInstancesOfClass

        public static long countInstancesOfClass(Class cls)
        Returns a count of the extant instances of a class.
      • getBinderSentTransactions

        public static int getBinderSentTransactions()
        Returns the number of sent transactions from this process.
        Returns:
        The number of sent transactions or -1 if it could not read t.
      • getBinderReceivedTransactions

        public static int getBinderReceivedTransactions()
        Returns the number of received transactions from the binder driver.
        Returns:
        The number of received transactions or -1 if it could not read the stats.
      • getBinderLocalObjectCount

        public static final int getBinderLocalObjectCount()
        Returns the number of active local Binder objects that exist in the current process.
      • getBinderProxyObjectCount

        public static final int getBinderProxyObjectCount()
        Returns the number of references to remote proxy Binder objects that exist in the current process.
      • getBinderDeathObjectCount

        public static final int getBinderDeathObjectCount()
        Returns the number of death notification links to Binder objects that exist in the current process.
      • cacheRegisterMap

        public static final boolean cacheRegisterMap(String classAndMethodDesc)
        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
        Parameters:
        classAndMethodDesc - the method to prepare
      • dumpReferenceTables

        public static final void dumpReferenceTables()
        Dumps the contents of VM reference tables (e.g. JNI locals and globals) to the log file.
      • setFieldsOn

        public static void setFieldsOn(Class<?> cl,
                       boolean partial)
        Reflectively sets static fields of a class based on internal debugging properties. This method is a no-op if false is false.

        NOTE TO APPLICATION DEVELOPERS: false will always be false in release builds. This API is typically only useful for platform developers.

        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:
         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;
        Parameters:
        cl - The class to (possibly) modify
        partial - If false, sets all static fields, otherwise, only set fields with the 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.
      • dumpService

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

        Parameters:
        name - of the service to dump
        fd - to write dump output to (usually an output log file)
        args - to pass to the service's dump method, may be null
        Returns:
        true if the service was dumped successfully, false if the service could not be found or had an error while dumping
      • dumpNativeBacktraceToFile

        public static void dumpNativeBacktraceToFile(int pid,
                                     String file)
        Have the stack traces of the given native process dumped to the specified file. Will be appended to the file.
      • getCallers

        public static String getCallers(int depth)
        Return a string consisting of methods and locations at multiple call stack levels.
        Parameters:
        depth - the number of levels to return, starting with the immediate caller.
        Returns:
        a string describing the call stack.
      • getCallers

        public static String getCallers(int depth,
                        String linePrefix)
        Like getCallers(int), but each location is append to the string as a new line with linePrefix in front of it.
        Parameters:
        depth - the number of levels to return, starting with the immediate caller.
        linePrefix - prefix to put in front of each location.
        Returns:
        a string describing the call stack.
      • getCaller

        public static String getCaller()
        Returns:
        a String describing the immediate caller of the calling function.


Content

Android Reference

Java basics

Java Enterprise Edition (EE)

Java Standard Edition (SE)

SQL

HTML

PHP

CSS

Java Script

MYSQL

JQUERY

VBS

REGEX

C

C++

C#

Design patterns

RFC (standard status)

RFC (proposed standard status)

RFC (draft standard status)

RFC (informational status)

RFC (experimental status)

RFC (best current practice status)

RFC (historic status)

RFC (unknown status)

IT dictionary

License.
All information of this service is derived from the free sources and is provided solely in the form of quotations. This service provides information and interfaces solely for the familiarization (not ownership) and under the "as is" condition.
Copyright 2016 © ELTASK.COM. All rights reserved.
Site is optimized for mobile devices.
Downloads: 279 / 158763943. Delta: 0.05831 с