/**@class android.os.Debug
@extends java.lang.Object

 Provides various debugging methods for Android applications, including
 tracing and allocation counts.
 <p><strong>Logging Trace Files</strong></p>
 <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}().
*/
var Debug = {

/** Flags for startMethodTracing().  These can be ORed together.

 TRACE_COUNT_ALLOCS adds the results from startAllocCounting to the
 trace key file.

 @deprecated Accurate counting is a burden on the runtime and may be removed.
*/
TRACE_COUNT_ALLOCS : "null",
/** Flags for printLoadedClasses().  Default behavior is to only show
 the class name.
*/
SHOW_FULL_DETAIL : "1",
/***/
SHOW_CLASSLOADER : "2",
/***/
SHOW_INITIALIZED : "4",
/**@hide */
MEMINFO_TOTAL : "0",
/**@hide */
MEMINFO_FREE : "1",
/**@hide */
MEMINFO_BUFFERS : "2",
/**@hide */
MEMINFO_CACHED : "3",
/**@hide */
MEMINFO_SHMEM : "4",
/**@hide */
MEMINFO_SLAB : "5",
/**@hide */
MEMINFO_SWAP_TOTAL : "6",
/**@hide */
MEMINFO_SWAP_FREE : "7",
/**@hide */
MEMINFO_ZRAM_TOTAL : "8",
/**@hide */
MEMINFO_MAPPED : "9",
/**@hide */
MEMINFO_VM_ALLOC_USED : "10",
/**@hide */
MEMINFO_PAGE_TABLES : "11",
/**@hide */
MEMINFO_KERNEL_STACK : "12",
/**@hide */
MEMINFO_COUNT : "13",
/**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.
*/
waitForDebugger : function(  ) {},

/**Returns "true" if one or more threads is waiting for a debugger
 to attach.
*/
waitingForDebugger : function(  ) {},

/**Determine if a debugger is currently attached.
*/
isDebuggerConnected : function(  ) {},

/**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 
*/
getVmFeatureList : function(  ) {},

/**Change the JDWP port.
@deprecated no longer needed or useful
*/
changeDebugPort : function(  ) {},

/**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</code><br />
 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>
*/
startNativeTracing : function(  ) {},

/**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>
*/
stopNativeTracing : function(  ) {},

/**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}().
*/
enableEmulatorTraceOutput : function(  ) {},

/**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.
*/
startMethodTracing : function(  ) {},

/**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 {String} traceName Name for the trace log file to create.
 If {@code traceName} is null, 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 : function(  ) {},

/**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 {String} traceName    Name for the trace log file to create.
 If {@code traceName} is null, 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 {Number} bufferSize    The maximum amount of trace data we gather. If not given, it defaults to 8MB.
*/
startMethodTracing : function(  ) {},

/**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 sampling-based method
 tracing via {@link #startMethodTracingSampling(String, int, int)} or
 "native" tracing in the emulator via {@link #startNativeTracing}().
 </p>
@param {String} traceName    Name for the trace log file to create.
 If {@code traceName} is null, 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 {Number} bufferSize    The maximum amount of trace data we gather. If not given, it defaults to 8MB.
@param {Number} flags    Flags to control method tracing. The only one that is currently defined is {@link #TRACE_COUNT_ALLOCS}.
*/
startMethodTracing : function(  ) {},

/**Start sampling-based method tracing, specifying the trace log file name,
 the buffer size, and the sampling interval. 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 {String} traceName    Name for the trace log file to create.
 If {@code traceName} is null, 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 {Number} bufferSize    The maximum amount of trace data we gather. If not given, it defaults to 8MB.
@param {Number} intervalUs    The amount of time between each sample in microseconds.
*/
startMethodTracingSampling : function(  ) {},

/**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 
*/
startMethodTracing : function(  ) {},

/**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 
*/
startMethodTracingDdms : function(  ) {},

/**Determine whether method tracing is currently active and what type is
 active.
@hide 
*/
getMethodTracingMode : function(  ) {},

/**Stop method tracing.
*/
stopMethodTracing : function(  ) {},

/**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.
*/
threadCpuTimeNanos : function(  ) {},

/**Start counting the number and aggregate size of memory allocations.

 <p>The {@link #startAllocCounting() start} method resets the counts and enables counting.
 The {@link #stopAllocCounting() stop} method disables the counting so that the analysis
 code doesn't cause additional allocations.  The various <code>get</code> methods return
 the specified value. And the various <code>reset</code> methods reset the specified
 count.</p>

 <p>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.</p>
@deprecated Accurate counting is a burden on the runtime and may be removed.
*/
startAllocCounting : function(  ) {},

/**Stop counting the number and aggregate size of memory allocations.
@deprecated Accurate counting is a burden on the runtime and may be removed.
*/
stopAllocCounting : function(  ) {},

/**Returns the global count of objects allocated by the runtime between a
 {@link #startAllocCounting() start} and {@link #stopAllocCounting() stop}.
@deprecated Accurate counting is a burden on the runtime and may be removed.
*/
getGlobalAllocCount : function(  ) {},

/**Clears the global count of objects allocated.
@see #getGlobalAllocCount()
@deprecated Accurate counting is a burden on the runtime and may be removed.
*/
resetGlobalAllocCount : function(  ) {},

/**Returns the global size, in bytes, of objects allocated by the runtime between a
 {@link #startAllocCounting() start} and {@link #stopAllocCounting() stop}.
@deprecated Accurate counting is a burden on the runtime and may be removed.
*/
getGlobalAllocSize : function(  ) {},

/**Clears the global size of objects allocated.
@see #getGlobalAllocSize()
@deprecated Accurate counting is a burden on the runtime and may be removed.
*/
resetGlobalAllocSize : function(  ) {},

/**Returns the global count of objects freed by the runtime between a
 {@link #startAllocCounting() start} and {@link #stopAllocCounting() stop}.
@deprecated Accurate counting is a burden on the runtime and may be removed.
*/
getGlobalFreedCount : function(  ) {},

/**Clears the global count of objects freed.
@see #getGlobalFreedCount()
@deprecated Accurate counting is a burden on the runtime and may be removed.
*/
resetGlobalFreedCount : function(  ) {},

/**Returns the global size, in bytes, of objects freed by the runtime between a
 {@link #startAllocCounting() start} and {@link #stopAllocCounting() stop}.
@deprecated Accurate counting is a burden on the runtime and may be removed.
*/
getGlobalFreedSize : function(  ) {},

/**Clears the global size of objects freed.
@see #getGlobalFreedSize()
@deprecated Accurate counting is a burden on the runtime and may be removed.
*/
resetGlobalFreedSize : function(  ) {},

/**Returns the number of non-concurrent GC invocations between a
 {@link #startAllocCounting() start} and {@link #stopAllocCounting() stop}.
@deprecated Accurate counting is a burden on the runtime and may be removed.
*/
getGlobalGcInvocationCount : function(  ) {},

/**Clears the count of non-concurrent GC invocations.
@see #getGlobalGcInvocationCount()
@deprecated Accurate counting is a burden on the runtime and may be removed.
*/
resetGlobalGcInvocationCount : function(  ) {},

/**Returns the number of classes successfully initialized (ie those that executed without
 throwing an exception) between a {@link #startAllocCounting() start} and
 {@link #stopAllocCounting() stop}.
@deprecated Accurate counting is a burden on the runtime and may be removed.
*/
getGlobalClassInitCount : function(  ) {},

/**Clears the count of classes initialized.
@see #getGlobalClassInitCount()
@deprecated Accurate counting is a burden on the runtime and may be removed.
*/
resetGlobalClassInitCount : function(  ) {},

/**Returns the time spent successfully initializing classes between a
 {@link #startAllocCounting() start} and {@link #stopAllocCounting() stop}.
@deprecated Accurate counting is a burden on the runtime and may be removed.
*/
getGlobalClassInitTime : function(  ) {},

/**Clears the count of time spent initializing classes.
@see #getGlobalClassInitTime()
@deprecated Accurate counting is a burden on the runtime and may be removed.
*/
resetGlobalClassInitTime : function(  ) {},

/**This method exists for compatibility and always returns 0.
@deprecated This method is now obsolete.
*/
getGlobalExternalAllocCount : function(  ) {},

/**This method exists for compatibility and has no effect.
@deprecated This method is now obsolete.
*/
resetGlobalExternalAllocSize : function(  ) {},

/**This method exists for compatibility and has no effect.
@deprecated This method is now obsolete.
*/
resetGlobalExternalAllocCount : function(  ) {},

/**This method exists for compatibility and always returns 0.
@deprecated This method is now obsolete.
*/
getGlobalExternalAllocSize : function(  ) {},

/**This method exists for compatibility and always returns 0.
@deprecated This method is now obsolete.
*/
getGlobalExternalFreedCount : function(  ) {},

/**This method exists for compatibility and has no effect.
@deprecated This method is now obsolete.
*/
resetGlobalExternalFreedCount : function(  ) {},

/**This method exists for compatibility and has no effect.
@deprecated This method is now obsolete.
*/
getGlobalExternalFreedSize : function(  ) {},

/**This method exists for compatibility and has no effect.
@deprecated This method is now obsolete.
*/
resetGlobalExternalFreedSize : function(  ) {},

/**Returns the thread-local count of objects allocated by the runtime between a
 {@link #startAllocCounting() start} and {@link #stopAllocCounting() stop}.
@deprecated Accurate counting is a burden on the runtime and may be removed.
*/
getThreadAllocCount : function(  ) {},

/**Clears the thread-local count of objects allocated.
@see #getThreadAllocCount()
@deprecated Accurate counting is a burden on the runtime and may be removed.
*/
resetThreadAllocCount : function(  ) {},

/**Returns the thread-local size of objects allocated by the runtime between a
 {@link #startAllocCounting() start} and {@link #stopAllocCounting() stop}.
@return {Number} The allocated size in bytes.
@deprecated Accurate counting is a burden on the runtime and may be removed.
*/
getThreadAllocSize : function(  ) {},

/**Clears the thread-local count of objects allocated.
@see #getThreadAllocSize()
@deprecated Accurate counting is a burden on the runtime and may be removed.
*/
resetThreadAllocSize : function(  ) {},

/**This method exists for compatibility and has no effect.
@deprecated This method is now obsolete.
*/
getThreadExternalAllocCount : function(  ) {},

/**This method exists for compatibility and has no effect.
@deprecated This method is now obsolete.
*/
resetThreadExternalAllocCount : function(  ) {},

/**This method exists for compatibility and has no effect.
@deprecated This method is now obsolete.
*/
getThreadExternalAllocSize : function(  ) {},

/**This method exists for compatibility and has no effect.
@deprecated This method is now obsolete.
*/
resetThreadExternalAllocSize : function(  ) {},

/**Returns the number of thread-local non-concurrent GC invocations between a
 {@link #startAllocCounting() start} and {@link #stopAllocCounting() stop}.
@deprecated Accurate counting is a burden on the runtime and may be removed.
*/
getThreadGcInvocationCount : function(  ) {},

/**Clears the thread-local count of non-concurrent GC invocations.
@see #getThreadGcInvocationCount()
@deprecated Accurate counting is a burden on the runtime and may be removed.
*/
resetThreadGcInvocationCount : function(  ) {},

/**Clears all the global and thread-local memory allocation counters.
@see #startAllocCounting()
@deprecated Accurate counting is a burden on the runtime and may be removed.
*/
resetAllCounts : function(  ) {},

/**Returns the value of a particular runtime statistic or {@code null} if no
 such runtime statistic exists.

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

 <table>
     <thead>
         <tr>
             <th>Runtime statistic name</th>
             <th>Meaning</th>
             <th>Example</th>
             <th>Supported (API Levels)</th>
         </tr>
     </thead>
     <tbody>
         <tr>
             <td>art.gc.gc-count</td>
             <td>The number of garbage collection runs.</td>
             <td>{@code 164}</td>
             <td>23</td>
         </tr>
         <tr>
             <td>art.gc.gc-time</td>
             <td>The total duration of garbage collection runs in ms.</td>
             <td>{@code 62364}</td>
             <td>23</td>
         </tr>
         <tr>
             <td>art.gc.bytes-allocated</td>
             <td>The total number of bytes that the application allocated.</td>
             <td>{@code 1463948408}</td>
             <td>23</td>
         </tr>
         <tr>
             <td>art.gc.bytes-freed</td>
             <td>The total number of bytes that garbage collection reclaimed.</td>
             <td>{@code 1313493084}</td>
             <td>23</td>
         </tr>
         <tr>
             <td>art.gc.blocking-gc-count</td>
             <td>The number of blocking garbage collection runs.</td>
             <td>{@code 2}</td>
             <td>23</td>
         </tr>
         <tr>
             <td>art.gc.blocking-gc-time</td>
             <td>The total duration of blocking garbage collection runs in ms.</td>
             <td>{@code 804}</td>
             <td>23</td>
         </tr>
         <tr>
             <td>art.gc.gc-count-rate-histogram</td>
             <td>Every 10 seconds, the gc-count-rate is computed as the number of garbage
                 collection runs that have occurred over the last 10
                 seconds. art.gc.gc-count-rate-histogram is a histogram of the gc-count-rate
                 samples taken since the process began. The histogram can be used to identify
                 instances of high rates of garbage collection runs. For example, a histogram
                 of "0:34503,1:45350,2:11281,3:8088,4:43,5:8" shows that most of the time
                 there are between 0 and 2 garbage collection runs every 10 seconds, but there
                 were 8 distinct 10-second intervals in which 5 garbage collection runs
                 occurred.</td>
             <td>{@code 0:34503,1:45350,2:11281,3:8088,4:43,5:8}</td>
             <td>23</td>
         </tr>
         <tr>
             <td>art.gc.blocking-gc-count-rate-histogram</td>
             <td>Every 10 seconds, the blocking-gc-count-rate is computed as the number of
                 blocking garbage collection runs that have occurred over the last 10
                 seconds. art.gc.blocking-gc-count-rate-histogram is a histogram of the
                 blocking-gc-count-rate samples taken since the process began. The histogram
                 can be used to identify instances of high rates of blocking garbage
                 collection runs. For example, a histogram of "0:99269,1:1,2:1" shows that
                 most of the time there are zero blocking garbage collection runs every 10
                 seconds, but there was one 10-second interval in which one blocking garbage
                 collection run occurred, and there was one interval in which two blocking
                 garbage collection runs occurred.</td>
             <td>{@code 0:99269,1:1,2:1}</td>
             <td>23</td>
         </tr>
     </tbody>
 </table>
@param {String} statName
            the name of the runtime statistic to look up.
@return {String} the value of the specified runtime statistic or {@code null} if the
         runtime statistic doesn't exist.
*/
getRuntimeStat : function(  ) {},

/**Returns a map of the names/values of the runtime statistics
 that {@link #getRuntimeStat}(String) supports.
@return {Object {java.util.Map}} a map of the names/values of the supported runtime statistics.
*/
getRuntimeStats : function(  ) {},

/**Returns the size of the native heap.
@return {Number} The size of the native heap in bytes.
*/
getNativeHeapSize : function(  ) {},

/**Returns the amount of allocated memory in the native heap.
@return {Number} The allocated size in bytes.
*/
getNativeHeapAllocatedSize : function(  ) {},

/**Returns the amount of free memory in the native heap.
@return {Number} The freed size in bytes.
*/
getNativeHeapFreeSize : function(  ) {},

/**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 : function(  ) {},

/**Note: currently only works when the requested pid has the same UID
 as the caller.
@hide 
*/
getMemoryInfo : function(  ) {},

/**Retrieves the PSS memory used by the process as given by the
 smaps.
*/
getPss : function(  ) {},

/**Retrieves the PSS memory used by the process as given by the
 smaps.  Optionally supply a long array of 1 entry to also
 receive the uss of the process, and another array to also
 retrieve the separate memtrack size.  @hide
*/
getPss : function(  ) {},

/**Retrieves /proc/meminfo.  outSizes is filled with fields
 as defined by MEMINFO_* offsets.
@hide 
*/
getMemInfo : function(  ) {},

/**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.
@deprecated This method is now obsolete.
*/
setAllocationLimit : function(  ) {},

/**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.
@deprecated This method is now obsolete.
*/
setGlobalAllocationLimit : function(  ) {},

/**Dump a list of all currently loaded class to the log file.
@param {Number} flags See constants above.
*/
printLoadedClasses : function(  ) {},

/**Get the number of loaded classes.
@return {Number} the number of loaded classes.
*/
getLoadedClassCount : function(  ) {},

/**Dump "hprof" data to the specified file.  This may cause a GC.
@param {String} 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.
*/
dumpHprofData : function(  ) {},

/**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.
@hide 
*/
dumpHprofData : function(  ) {},

/**Collect "hprof" and send it to DDMS.  This may cause a GC.
@throws UnsupportedOperationException if the VM was built without
         HPROF support.
@hide 
*/
dumpHprofDataDdms : function(  ) {},

/**Writes native heap data to the specified file descriptor.
@hide 
*/
dumpNativeHeap : function(  ) {},

/**Returns a count of the extant instances of a class.
@hide 
*/
countInstancesOfClass : function(  ) {},

/**Returns the number of sent transactions from this process.
@return {Number} The number of sent transactions or -1 if it could not read t.
*/
getBinderSentTransactions : function(  ) {},

/**Returns the number of received transactions from the binder driver.
@return {Number} The number of received transactions or -1 if it could not read the stats.
*/
getBinderReceivedTransactions : function(  ) {},

/**Returns the number of active local Binder objects that exist in the
 current process.
*/
getBinderLocalObjectCount : function(  ) {},

/**Returns the number of references to remote proxy Binder objects that
 exist in the current process.
*/
getBinderProxyObjectCount : function(  ) {},

/**Returns the number of death notification links to Binder objects that
 exist in the current process.
*/
getBinderDeathObjectCount : function(  ) {},

/**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 {String} classAndMethodDesc the method to prepare
@hide 
*/
cacheRegisterMap : function(  ) {},

/**Dumps the contents of VM reference tables (e.g. JNI locals and
 globals) to the log file.
@hide 
*/
dumpReferenceTables : function(  ) {},

/**Equivalent to <code>setFieldsOn(cl, false)</code>.
@see #setFieldsOn(Class, boolean)
@hide 
*/
setFieldsOn : function(  ) {},

/**Reflectively sets static fields of a class based on internal debugging
 properties.  This method is a no-op if false is
 false.
 <p>
 <strong>NOTE TO APPLICATION DEVELOPERS</strong>: false 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;
@param {Object {java.lang.Class}} cl The class to (possibly) modify
@param {Boolean} partial If false, sets all static fields, otherwise, only set
        fields with the {@link android.os.Debug.DebugProperty}
        annotation
@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.
*/
setFieldsOn : function(  ) {},

/**Get a debugging dump of a system service by name.

 <p>Most services require the caller to hold android.permission.DUMP.
@param {String} name of the service to dump
@param {Object {FileDescriptor}} fd to write dump output to (usually an output log file)
@param {Object {java.lang.String[]}} args to pass to the service's dump method, may be null
@return {Boolean} true if the service was dumped successfully, false if
     the service could not be found or had an error while dumping
*/
dumpService : function(  ) {},

/**Have the stack traces of the given native process dumped to the
 specified file.  Will be appended to the file.
@hide 
*/
dumpNativeBacktraceToFile : function(  ) {},

/**Return a string consisting of methods and locations at multiple call stack levels.
@param {Number} depth the number of levels to return, starting with the immediate caller.
@return {String} a string describing the call stack.
 {@hide}
*/
getCallers : function(  ) {},

/**Return a string consisting of methods and locations at multiple call stack levels.
@param {Number} depth the number of levels to return, starting with the immediate caller.
@return {String} a string describing the call stack.
 {@hide}
*/
getCallers : function(  ) {},

/**Like {@link #getCallers}(int), but each location is append to the string
 as a new line with <var>linePrefix</var> in front of it.
@param {Number} depth the number of levels to return, starting with the immediate caller.
@param {String} linePrefix prefix to put in front of each location.
@return {String} a string describing the call stack.
 {@hide}
*/
getCallers : function(  ) {},

/**
@return {String} a String describing the immediate caller of the calling method.
 {@hide}
*/
getCaller : function(  ) {},


};