1 files changed, 143 insertions, 0 deletions
diff --git a/packages/Keyguard/src/com/android/keyguard/LatencyTracker.java b/packages/Keyguard/src/com/android/keyguard/LatencyTracker.java
new file mode 100644
index 000000000000..f1b61269dd67
--- /dev/null
+++ b/packages/Keyguard/src/com/android/keyguard/LatencyTracker.java
@@ -0,0 +1,143 @@
+/*
+ * Copyright (C) 2016 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.keyguard;
+
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.os.Build;
+import android.os.SystemClock;
+import android.os.SystemProperties;
+import android.os.Trace;
+import android.util.EventLog;
+import android.util.Log;
+import android.util.SparseLongArray;
+
+import com.android.systemui.EventLogTags;
+
+/**
+ * Class to track various latencies in SystemUI. It then outputs the latency to logcat so these
+ * latencies can be captured by tests and then used for dashboards.
+ * <p>
+ * This is currently only in Keyguard so it can be shared between SystemUI and Keyguard, but
+ * eventually we'd want to merge these two packages together so Keyguard can use common classes
+ * that are shared with SystemUI.
+ */
+public class LatencyTracker {
+
+    private static final String ACTION_RELOAD_PROPERTY =
+            "com.android.systemui.RELOAD_LATENCY_TRACKER_PROPERTY";
+
+    private static final String TAG = "LatencyTracker";
+
+    /**
+     * Time it takes until the first frame of the notification panel to be displayed while expanding
+     */
+    public static final int ACTION_EXPAND_PANEL = 0;
+
+    /**
+     * Time it takes until the first frame of recents is drawn after invoking it with the button.
+     */
+    public static final int ACTION_TOGGLE_RECENTS = 1;
+
+    /**
+     * Time between we get a fingerprint acquired signal until we start with the unlock animation
+     */
+    public static final int ACTION_FINGERPRINT_WAKE_AND_UNLOCK = 2;
+
+    /**
+     * Time it takes to check PIN/Pattern/Password.
+     */
+    public static final int ACTION_CHECK_CREDENTIAL = 3;
+
+    /**
+     * Time it takes to check fully PIN/Pattern/Password, i.e. that's the time spent including the
+     * actions to unlock a user.
+     */
+    public static final int ACTION_CHECK_CREDENTIAL_UNLOCKED = 4;
+
+    private static final String[] NAMES = new String[] {
+            "expand panel",
+            "toggle recents",
+            "fingerprint wake-and-unlock",
+            "check credential",
+            "check credential unlocked" };
+
+    private static LatencyTracker sLatencyTracker;
+
+    private final SparseLongArray mStartRtc = new SparseLongArray();
+    private boolean mEnabled;
+
+    public static LatencyTracker getInstance(Context context) {
+        if (sLatencyTracker == null) {
+            sLatencyTracker = new LatencyTracker(context);
+        }
+        return sLatencyTracker;
+    }
+
+    private LatencyTracker(Context context) {
+        context.registerReceiver(new BroadcastReceiver() {
+            @Override
+            public void onReceive(Context context, Intent intent) {
+                reloadProperty();
+            }
+        }, new IntentFilter(ACTION_RELOAD_PROPERTY));
+        reloadProperty();
+    }
+
+    private void reloadProperty() {
+        mEnabled = SystemProperties.getBoolean("debug.systemui.latency_tracking", false);
+    }
+
+    public static boolean isEnabled(Context ctx) {
+        return Build.IS_DEBUGGABLE && getInstance(ctx).mEnabled;
+    }
+
+    /**
+     * Notifies that an action is starting. This needs to be called from the main thread.
+     *
+     * @param action The action to start. One of the ACTION_* values.
+     */
+    public void onActionStart(int action) {
+        if (!mEnabled) {
+            return;
+        }
+        Trace.asyncTraceBegin(Trace.TRACE_TAG_APP, NAMES[action], 0);
+        mStartRtc.put(action, SystemClock.elapsedRealtime());
+    }
+
+    /**
+     * Notifies that an action has ended. This needs to be called from the main thread.
+     *
+     * @param action The action to end. One of the ACTION_* values.
+     */
+    public void onActionEnd(int action) {
+        if (!mEnabled) {
+            return;
+        }
+        long endRtc = SystemClock.elapsedRealtime();
+        long startRtc = mStartRtc.get(action, -1);
+        if (startRtc == -1) {
+            return;
+        }
+        Trace.asyncTraceEnd(Trace.TRACE_TAG_APP, NAMES[action], 0);
+        long duration = endRtc - startRtc;
+        Log.i(TAG, "action=" + action + " latency=" + duration);
+        EventLog.writeEvent(EventLogTags.SYSUI_LATENCY, action, (int) duration);
+    }
+}