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

 Writes trace events to the system trace buffer.  These trace events can be
 collected and visualized using the Systrace tool.

 <p>This tracing mechanism is independent of the method tracing mechanism
 offered by {@link android.os.Debug#startMethodTracing}.  In particular, it enables
 tracing of events that occur across multiple processes.
 <p>For information about using the Systrace tool, read <a
 href="{@docRoot}tools/debugging/systrace.html">Analyzing Display and Performance
 with Systrace</a>.
*/
var Trace = {

/**@hide */
TRACE_TAG_NEVER : "0",
/**@hide */
TRACE_TAG_ALWAYS : "1",
/**@hide */
TRACE_TAG_GRAPHICS : "2",
/**@hide */
TRACE_TAG_INPUT : "4",
/**@hide */
TRACE_TAG_VIEW : "8",
/**@hide */
TRACE_TAG_WEBVIEW : "16",
/**@hide */
TRACE_TAG_WINDOW_MANAGER : "32",
/**@hide */
TRACE_TAG_ACTIVITY_MANAGER : "64",
/**@hide */
TRACE_TAG_SYNC_MANAGER : "128",
/**@hide */
TRACE_TAG_AUDIO : "256",
/**@hide */
TRACE_TAG_VIDEO : "512",
/**@hide */
TRACE_TAG_CAMERA : "1024",
/**@hide */
TRACE_TAG_HAL : "2048",
/**@hide */
TRACE_TAG_APP : "4096",
/**@hide */
TRACE_TAG_RESOURCES : "8192",
/**@hide */
TRACE_TAG_DALVIK : "16384",
/**@hide */
TRACE_TAG_RS : "32768",
/**@hide */
TRACE_TAG_BIONIC : "65536",
/**@hide */
TRACE_TAG_POWER : "131072",
/**@hide */
TRACE_TAG_PACKAGE_MANAGER : "262144",
/**@hide */
TRACE_TAG_SYSTEM_SERVER : "524288",
/**@hide */
TRACE_TAG_DATABASE : "1048576",
/**@hide */
TRACE_TAG_NETWORK : "2097152",
/**@hide */
TRACE_TAG_ADB : "4194304",
/**@hide */
TRACE_TAG_VIBRATOR : "8388608",
/**@hide */
TRACE_TAG_AIDL : "16777216",
/**@hide */
TRACE_TAG_NNAPI : "33554432",
/**@hide */
TRACE_TAG_RRO : "67108864",
/**Returns true if a trace tag is enabled.
@param {Number} traceTag The trace tag to check.
@return {Boolean} True if the trace tag is valid.
@hide 
*/
isTagEnabled : function(  ) {},

/**Writes trace message to indicate the value of a given counter.
@param {Number} traceTag The trace tag.
@param {String} counterName The counter name to appear in the trace.
@param {Number} counterValue The counter value.
@hide 
*/
traceCounter : function(  ) {},

/**Set whether application tracing is allowed for this process.  This is intended to be set
 once at application start-up time based on whether the application is debuggable.
@hide 
*/
setAppTracingAllowed : function(  ) {},

/**Set whether tracing is enabled in this process.  Tracing is disabled shortly after Zygote
 initializes and re-enabled after processes fork from Zygote.  This is done because Zygote
 has no way to be notified about changes to the tracing tags, and if Zygote ever reads and
 caches the tracing tags, forked processes will inherit those stale tags.
@hide 
*/
setTracingEnabled : function(  ) {},

/**Writes a trace message to indicate that a given section of code has
 begun. Must be followed by a call to {@link #traceEnd} using the same
 tag.
@param {Number} traceTag The trace tag.
@param {String} methodName The method name to appear in the trace.
@hide 
*/
traceBegin : function(  ) {},

/**Writes a trace message to indicate that the current method has ended.
 Must be called exactly once for each call to {@link #traceBegin} using the same tag.
@param {Number} traceTag The trace tag.
@hide 
*/
traceEnd : function(  ) {},

/**Writes a trace message to indicate that a given section of code has
 begun. Must be followed by a call to {@link #asyncTraceEnd} using the same
 tag. Unlike {@link #traceBegin(long, String)} and {@link #traceEnd}(long),
 asynchronous events do not need to be nested. The name and cookie used to
 begin an event must be used to end it.
@param {Number} traceTag The trace tag.
@param {String} methodName The method name to appear in the trace.
@param {Number} cookie Unique identifier for distinguishing simultaneous events
@hide 
*/
asyncTraceBegin : function(  ) {},

/**Writes a trace message to indicate that the current method has ended.
 Must be called exactly once for each call to {@link #asyncTraceBegin(long, String, int)}
 using the same tag, name and cookie.
@param {Number} traceTag The trace tag.
@param {String} methodName The method name to appear in the trace.
@param {Number} cookie Unique identifier for distinguishing simultaneous events
@hide 
*/
asyncTraceEnd : function(  ) {},

/**Checks whether or not tracing is currently enabled. This is useful to avoid intermediate
 string creation for trace sections that require formatting. It is not necessary
 to guard all Trace method calls as they internally already check this. However it is
 recommended to use this to prevent creating any temporary objects that would then be
 passed to those methods to reduce runtime cost when tracing isn't enabled.
@return {Boolean} true if tracing is currently enabled, false otherwise
*/
isEnabled : function(  ) {},

/**Writes a trace message to indicate that a given section of code has begun. This call must
 be followed by a corresponding call to {@link #endSection}() on the same thread.

 <p class="note"> At this time the vertical bar character '|', newline character '\n', and
 null character '\0' are used internally by the tracing mechanism.  If sectionName contains
 these characters they will be replaced with a space character in the trace.
@param {String} sectionName The name of the code section to appear in the trace.  This may be at
 most 127 Unicode code units long.
*/
beginSection : function(  ) {},

/**Writes a trace message to indicate that a given section of code has ended. This call must
 be preceeded by a corresponding call to {@link #beginSection}(String). Calling this method
 will mark the end of the most recently begun section of code, so care must be taken to
 ensure that beginSection / endSection pairs are properly nested and called from the same
 thread.
*/
endSection : function(  ) {},

/**Writes a trace message to indicate that a given section of code has
 begun. Must be followed by a call to {@link #endAsyncSection(String, int)} with the same
 methodName and cookie. Unlike {@link #beginSection}(String) and {@link #endSection}(),
 asynchronous events do not need to be nested. The name and cookie used to
 begin an event must be used to end it.
@param {String} methodName The method name to appear in the trace.
@param {Number} cookie Unique identifier for distinguishing simultaneous events
*/
beginAsyncSection : function(  ) {},

/**Writes a trace message to indicate that the current method has ended.
 Must be called exactly once for each call to {@link #beginAsyncSection(String, int)}
 using the same name and cookie.
@param {String} methodName The method name to appear in the trace.
@param {Number} cookie Unique identifier for distinguishing simultaneous events
*/
endAsyncSection : function(  ) {},

/**Writes trace message to indicate the value of a given counter.
@param {String} counterName The counter name to appear in the trace.
@param {Number} counterValue The counter value.
*/
setCounter : function(  ) {},


};