diff options
author | Igor Murashkin <iam@google.com> | 2013-10-25 22:10:46 +0000 |
---|---|---|
committer | Android (Google) Code Review <android-gerrit@google.com> | 2013-10-25 22:10:46 +0000 |
commit | 1e125c7179c4226702a0c5d7943380529187f989 (patch) | |
tree | 5dca7f1449c4c6000edbc7165c4edc42eeb178ca | |
parent | 806d114d5975c89843c9ba16eadfcaf143afdebb (diff) | |
parent | 30662b3366c815603d3ed61dc3868e0ea40788e7 (diff) | |
download | android_frameworks_ex-1e125c7179c4226702a0c5d7943380529187f989.tar.gz android_frameworks_ex-1e125c7179c4226702a0c5d7943380529187f989.tar.bz2 android_frameworks_ex-1e125c7179c4226702a0c5d7943380529187f989.zip |
Merge "gcam: Add empty SysTrace class" into klp-dev
-rw-r--r-- | camera2/public/src/com/android/ex/camera2/utils/SysTrace.java | 121 |
1 files changed, 121 insertions, 0 deletions
diff --git a/camera2/public/src/com/android/ex/camera2/utils/SysTrace.java b/camera2/public/src/com/android/ex/camera2/utils/SysTrace.java new file mode 100644 index 0000000..fd92216 --- /dev/null +++ b/camera2/public/src/com/android/ex/camera2/utils/SysTrace.java @@ -0,0 +1,121 @@ +/* + * Copyright 2013 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 com.android.ex.camera2.utils; + +import android.util.Log; + +/** + * 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 Debug#startMethodTracing}. In particular, it enables + * tracing of events that occur across multiple processes. + * </p> + * + * <p> + * All traces are written using the <pre>APP</pre> tag. + * </p> + */ +public final class SysTrace { + + private static final String TAG = "SysTrace"; + private static final boolean VERBOSE = Log.isLoggable(TAG, Log.VERBOSE); + + private static int sNestingLevel = 0; + + /** + * Writes trace message to indicate the value of a given counter. + * + * @param counterName The counter name to appear in the trace. + * @param counterValue The counter value. + * + */ + public static void traceCounter(String counterName, int counterValue) { + if (VERBOSE) { + Log.v(TAG, "traceCounter " + counterName + " " + counterValue); + } + } + + /** + * 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 sectionName The name of the code section to appear in the trace. This may be at + * most 127 Unicode code units long. + */ + public static void beginSection(String sectionName) { + if (VERBOSE) { + Log.v(TAG, String.format("beginSection[%d] %s", sNestingLevel, sectionName)); + sNestingLevel++; + } + } + + /** + * Writes a trace message to indicate that a given section of code has + * ended. + * <p> + * This call must be preceded 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. + * </p> + */ + public static void endSection() { + if (VERBOSE) { + sNestingLevel--; + Log.v(TAG, String.format("endSection[%d]", sNestingLevel)); + } + } + + /** + * Writes a trace message to indicate that a given section of code has + * begun. + * + * <p>Must be followed by a call to {@link #endSectionAsync} using the same + * tag. Unlike {@link #beginSection} 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.</p> + * + * @param methodName The method name to appear in the trace. + * @param cookie Unique identifier for distinguishing simultaneous events + */ + public static void beginSectionAsync(String methodName, int cookie) { + if (VERBOSE) { + Log.v(TAG, "beginSectionAsync " + methodName + " " + cookie); + } + } + + /** + * Writes a trace message to indicate that the current method has ended. + * Must be called exactly once for each call to {@link #beginSectionAsync} + * using the same tag, name and cookie. + * + * @param methodName The method name to appear in the trace. + * @param cookie Unique identifier for distinguishing simultaneous events + */ + public static void endSectionAsync(String methodName, int cookie) { + if (VERBOSE) { + Log.v(TAG, "endSectionAsync " + methodName + " " + cookie); + } + } +} |