diff --git a/uiautomator_test_libraries/Android.mk b/uiautomator_test_libraries/Android.mk
new file mode 100644
index 0000000..f975016
--- /dev/null
+++ b/uiautomator_test_libraries/Android.mk
@@ -0,0 +1,33 @@
+#
+# Copyright (C) 2012 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.
+#
+local_target_dir := $(TARGET_OUT_DATA)/local/tmp
+LOCAL_PATH := $(call my-dir)
+
+include $(CLEAR_VARS)
+
+LOCAL_SRC_FILES := $(call all-java-files-under, src)
+
+LOCAL_MODULE := com.android.uiautomator.platform.common
+
+LOCAL_SDK_VERSION := 16
+
+LOCAL_JAVA_LIBRARIES := uiautomator_sdk_v$(LOCAL_SDK_VERSION)
+
+LOCAL_MODULE_TAGS := optional
+
+LOCAL_MODULE_PATH := $(local_target_dir)
+
+include $(BUILD_STATIC_JAVA_LIBRARY)
diff --git a/uiautomator_test_libraries/src/com/android/uiautomator/common/helpers/AppHelperBase.java b/uiautomator_test_libraries/src/com/android/uiautomator/common/helpers/AppHelperBase.java
new file mode 100644
index 0000000..9bd474e
--- /dev/null
+++ b/uiautomator_test_libraries/src/com/android/uiautomator/common/helpers/AppHelperBase.java
@@ -0,0 +1,96 @@
+/*
+ * Copyright (C) 2012 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.uiautomator.common.helpers;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+
+/**
+ * Base app helper class intended for all app helper to extend.
+ * This class provides common APIs that are expected to be present across
+ * all app helpers.
+ */
+public abstract class AppHelperBase {
+
+    /*
+     * App helpers should provide methods for accessing various UI widgets.
+     * Assume the app has an Action Bar, the helper should provide something similar to
+     * SomeAppHelper.ActionBar.getRefreshButton(). Methods like this help the tests check the
+     * state of the targeted widget as well as clicking it if need be. These types of methods are
+     * referred to as object getters. If there are different components, consider creating internal
+     * name spaces as in the .ActionBar example for better context.
+     *
+     * Adding basic units of functionality APIs is also very helpful to test.
+     * Consider the Alarm clock application as an example. It would be helpful if its helper
+     * provided basic functionality such as, setAlarm(Date) and deleteAlarm(Date). Such basic
+     * and key functionality helper methods, will abstract the tests from the UI implementation and
+     * make tests more reliable.
+     */
+
+    /**
+     * Launches the application.
+     *
+     * This is typically performed by executing a shell command to launch the application
+     * via Intent. It is possible to launch the application by automating the Launcher
+     * views and finding the target app icon to launch, however, this is prone to failure if
+     * the Launcher UI implementation differ from one platform to another.
+     */
+    abstract public void open();
+
+    /**
+     * Checks if the application is in foreground.
+     *
+     * This is typically performed by verifying the current package name of the foreground
+     * application. See UiDevice.getCurrentPackageName()
+     * @return true if open, else false.
+     */
+    abstract public boolean isOpen();
+
+
+    /**
+     * Helper to execute a shell command.
+     * @param command
+     */
+    protected void runShellCommand(String command) {
+        Process p = null;
+        BufferedReader resultReader = null;
+        try {
+            p = Runtime.getRuntime().exec(command);
+            int status = p.waitFor();
+            if (status != 0) {
+                System.err.println(String.format("Run shell command: %s, status: %s", command,
+                        status));
+            }
+        } catch (IOException e) {
+            System.err.println("// Exception from command " + command + ":");
+            System.err.println(e.toString());
+        } catch (InterruptedException e) {
+            System.err.println("// Interrupted while waiting for the command to finish. ");
+            System.err.println(e.toString());
+        } finally {
+            try {
+                if (resultReader != null) {
+                    resultReader.close();
+                }
+                if (p != null) {
+                    p.destroy();
+                }
+            } catch (IOException e) {
+                System.err.println(e.toString());
+            }
+        }
+    }
+}
diff --git a/uiautomator_test_libraries/src/com/android/uiautomator/platform/JankTestBase.java b/uiautomator_test_libraries/src/com/android/uiautomator/platform/JankTestBase.java
new file mode 100644
index 0000000..1e554bd
--- /dev/null
+++ b/uiautomator_test_libraries/src/com/android/uiautomator/platform/JankTestBase.java
@@ -0,0 +1,306 @@
+/*
+ * Copyright (C) 2012 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.uiautomation.platform;
+
+import android.os.Bundle;
+import android.os.Environment;
+import android.util.Log;
+
+import com.android.uiautomator.core.UiDevice;
+import com.android.uiautomator.testrunner.UiAutomatorTestCase;
+
+import java.io.BufferedWriter;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.util.Properties;
+
+/**
+ * Helper class for jankiness test.
+ * All the jank test must extend the JankBaseHelper
+ */
+public class JankTestBase extends UiAutomatorTestCase {
+    protected UiDevice mDevice;
+    protected BufferedWriter mWriter = null;
+    protected BufferedWriter mStatusWriter = null;
+    protected int mIteration = 1; // default iteration is set 1
+    protected Bundle mParams;
+    protected String mTestCaseName;
+    protected int mSuccessTestRuns = 0;
+
+    private final static String TAG = "BasePerformance";
+    // holds all params for the derived tests
+    private final static String PROPERTY_FILE_NAME = "UiJankinessTests.conf";
+    private final static String PARAM_CONFIG = "conf";
+    private final static String LOCAL_TMP_DIR = "/data/local/tmp/";
+    // File that hold the test results
+    private static String OUTPUT_FILE_NAME = LOCAL_TMP_DIR + "UiJankinessTestsOutput.txt";
+    // File that hold test status, e.g successful test iterations
+    private static String STATUS_FILE_NAME = LOCAL_TMP_DIR + "UiJankinessTestsStatus.txt";
+    private static int SUCCESS_THRESHOLD = 80;
+    private static boolean DEBUG = false;
+
+    /* Array to record jankiness data in each test iteration */
+    private int[] jankinessArray;
+    /* Array to record frame rate in each test iteration */
+    private double[] frameRateArray;
+    /* Array to save max accumulated frame number in each test iteration */
+    private int[] maxDeltaVsyncArray;
+
+    @Override
+    protected void setUp() throws Exception {
+        super.setUp();
+        mDevice = UiDevice.getInstance();
+
+        mWriter = new BufferedWriter(new FileWriter(new File(OUTPUT_FILE_NAME), true));
+        mStatusWriter = new BufferedWriter(new FileWriter(new File(STATUS_FILE_NAME), true));
+
+        mParams = getParams();
+        if (mParams != null && !mParams.isEmpty()) {
+            log("mParams is not empty, get properties.");
+            String mIterationStr;
+            if ((mIterationStr = getPropertyString(mParams, "iteration")) != null) {
+                mIteration = Integer.valueOf(mIterationStr);
+            }
+        }
+        jankinessArray = new int[mIteration];
+        frameRateArray = new double[mIteration];
+        maxDeltaVsyncArray = new int[mIteration];
+        mTestCaseName = this.getName();
+
+        mSuccessTestRuns = 0;
+        mDevice.pressHome();
+    }
+
+    /**
+     * Expects a file from the command line via conf param or default following format each on its
+     * own line. <code>
+     *    key=Value
+     *    Browser_URL1=cnn.com
+     *    Browser_URL2=google.com
+     *    Camera_ShutterDelay=1000
+     *    etc...
+     * </code>
+     * @param Bundle params
+     * @param key
+     * @return the value of the property else defaultValue
+     * @throws FileNotFoundException
+     * @throws IOException
+     */
+    protected String getPropertyString(Bundle params, String key)
+            throws FileNotFoundException, IOException {
+        Properties prop = new Properties();
+        prop.load(new FileInputStream(new File(LOCAL_TMP_DIR,
+                params.getString(PARAM_CONFIG, PROPERTY_FILE_NAME))));
+        String value = prop.getProperty(key);
+        if (value != null && !value.isEmpty())
+            return value;
+        return null;
+    }
+
+    /**
+     * Expects a file from the command line via conf param or default following format each on its
+     * own line. <code>
+     *    key=Value
+     *    Browser_URL1=cnn.com
+     *    Browser_URL2=google.com
+     *    Camera_ShutterDelay=1000
+     *    etc...
+     * </code>
+     * @param Bundle params
+     * @param key
+     * @return the value of the property else defaultValue
+     * @throws FileNotFoundException
+     * @throws IOException
+     */
+    protected long getPropertyLong(Bundle params, String key)
+            throws FileNotFoundException, IOException {
+        Properties prop = new Properties();
+        prop.load(new FileInputStream(new File(LOCAL_TMP_DIR,
+                params.getString(PARAM_CONFIG, PROPERTY_FILE_NAME))));
+        String value = prop.getProperty(key);
+        if (value != null && !value.trim().isEmpty())
+            return Long.valueOf(value.trim());
+        return 0;
+    }
+
+    /**
+     * Process the raw data, calculate jankiness, frame rate and max accumulated frames number
+     * @param testCaseName
+     * @param iteration
+     */
+    protected void recordResults(String testCaseName, int iteration) {
+        long refreshPeriod = SurfaceFlingerHelper.getRefreshPeriod();
+        // get jankiness count
+        int jankinessCount = SurfaceFlingerHelper.getVsyncJankiness();
+        // get frame rate
+        double frameRate = SurfaceFlingerHelper.getFrameRate();
+        // get max accumulated frames
+        int maxDeltaVsync = SurfaceFlingerHelper.getMaxDeltaVsync();
+
+        // only record data when they are valid
+        if (jankinessCount >=0 && frameRate > 0) {
+            jankinessArray[iteration] = jankinessCount;
+            frameRateArray[iteration] = frameRate;
+            maxDeltaVsyncArray[iteration] = maxDeltaVsync;
+            mSuccessTestRuns++;
+        }
+        String msg = String.format("%s, iteration %d\n" +
+                "refresh period: %d\n" +
+                "jankiness count: %d\n" +
+                "frame rate: %f\n" +
+                "max accumulated frames: %d\n",
+                testCaseName, iteration, refreshPeriod,
+                jankinessCount, frameRate, maxDeltaVsync);
+        log(msg);
+        if (DEBUG) {
+            SurfaceFlingerHelper.printData(testCaseName, iteration);
+        }
+    }
+
+    /**
+     * Process data from all test iterations, and save to disk
+     * @param testCaseName
+     */
+    protected void saveResults(String testCaseName) {
+        // write test status into status file
+        try {
+            mStatusWriter.write(String.format("%s: %d success runs out of %d iterations\n",
+                    testCaseName, mSuccessTestRuns, mIteration));
+        } catch (IOException e) {
+            log("failed to write output for test case " + testCaseName);
+        }
+
+        // if successful test runs is less than the threshold, no results will be saved.
+        if (mSuccessTestRuns * 100 / mIteration < SUCCESS_THRESHOLD) {
+            log(String.format("In %s, # of successful test runs out of %s iterations: %d ",
+                    testCaseName, mIteration, mSuccessTestRuns));
+            log(String.format("threshold is %d%%", SUCCESS_THRESHOLD));
+            return;
+        }
+
+        if (DEBUG) {
+            print(jankinessArray, "jankiness array");
+            print(frameRateArray, "frame rate array");
+            print(maxDeltaVsyncArray, "max delta vsync array");
+        }
+        double avgJankinessCount = getAverage(jankinessArray);
+        int maxJankinessCount = getMaxValue(jankinessArray);
+        double avgFrameRate = getAverage(frameRateArray);
+        double avgMaxDeltaVsync = getAverage(maxDeltaVsyncArray);
+
+        String avgMsg = String.format("%s\n" +
+                "average number of jankiness: %f\n" +
+                "max number of jankiness: %d\n" +
+                "average frame rate: %f\n" +
+                "average of max accumulated frames: %f\n",
+                testCaseName, avgJankinessCount, maxJankinessCount, avgFrameRate, avgMaxDeltaVsync);
+        log(avgMsg);
+
+        try {
+            mWriter.write(avgMsg);
+        } catch (IOException e) {
+            log("failed to write output for test case " + testCaseName);
+        }
+    }
+
+    // return the max value in an integer array
+    private int getMaxValue(int[] intArray) {
+        int index = 0;
+        int max = intArray[index];
+        for (int i  = 1; i < intArray.length; i++) {
+            if (max < intArray[i]) {
+                max = intArray[i];
+            }
+        }
+        return max;
+    }
+
+    private double getAverage(int[] intArray) {
+        int mean = 0;
+        int numberTests = 0;
+        for (int i = 0; i < intArray.length; i++) {
+            // in case in some iteration, test fails, no data points is collected
+            if (intArray[i] >= 0) {
+                mean += intArray[i];
+                ++numberTests;
+            }
+        }
+        return (double)mean/numberTests;
+    }
+
+    private double getAverage(double[] doubleArray) {
+        double mean = 0;
+        int numberTests = 0;
+        for (int i = 0; i < doubleArray.length; i++) {
+            // in case in some iteration, test fails, no data points is collected
+            if (doubleArray[i] >= 0) {
+                mean += doubleArray[i];
+                ++numberTests;
+            }
+        }
+        return mean/numberTests;
+    }
+
+    private void print(int[] intArray, String arrayName) {
+        log("start to print array for " + arrayName);
+        for (int i = 0; i < intArray.length; i++) {
+            log(String.format("%d: %d", i, intArray[i]));
+        }
+    }
+
+    private void print(double[] doubleArray, String arrayName) {
+        log("start to print array for " + arrayName);
+        for (int i = 0; i < doubleArray.length; i++) {
+            log(String.format("%d: %f", i, doubleArray[i]));
+        }
+    }
+
+    @Override
+    protected void tearDown() throws Exception {
+        super.tearDown();
+        if (mWriter != null) {
+            mWriter.close();
+        }
+        if (mStatusWriter != null) {
+            mStatusWriter.close();
+        }
+    }
+
+   private void log(String message) {
+       Log.v(TAG, message);
+   }
+
+   /**
+    * Set the total number of test iteration
+    * @param iteration
+    */
+   protected void setIteration(int iteration){
+       mIteration = iteration;
+   }
+
+   /**
+    * Get the total number of test iteration
+    * @return iteration
+    */
+   protected int getIteration(){
+       return mIteration;
+   }
+
+}
diff --git a/uiautomator_test_libraries/src/com/android/uiautomator/platform/SurfaceFlingerHelper.java b/uiautomator_test_libraries/src/com/android/uiautomator/platform/SurfaceFlingerHelper.java
new file mode 100644
index 0000000..f072d95
--- /dev/null
+++ b/uiautomator_test_libraries/src/com/android/uiautomator/platform/SurfaceFlingerHelper.java
@@ -0,0 +1,419 @@
+/*
+ * Copyright (C) 2012 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.uiautomation.platform;
+
+import android.os.Environment;
+import android.util.Log;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.ArrayList;
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileWriter;
+import java.io.BufferedWriter;
+import java.io.InputStreamReader;
+import java.io.IOException;
+import java.lang.Math;
+
+/*
+ * Tools to measure jankiness through SurfaceFlinger
+ */
+public class SurfaceFlingerHelper {
+    private static String TAG = "SurfaceFlingerHelper";
+    private static int BUFFER_SIZE = 128;
+    private static int BUFFER_NUMBER = 3;
+    private static String CLEAR_BUFFER_CMD = "dumpsys SurfaceFlinger --latency-clear %s";
+    private static String FRAME_LATENCY_CMD = "dumpsys SurfaceFlinger --latency %s";
+    private final static String RAW_DATA_DIR = "UiJankinessRawData";
+    private final static String LOCAL_TMP_DIR = "/data/local/tmp/";
+    /* If the latency between two frames is greater than this number, it it treated as a pause
+     * not a jankiness */
+    private final static int PAUSE_LATENCY = 20;
+
+    /* An array list which includes the raw buffer information from frame latency tool */
+    private static List<List<String>> mFrameBufferData = new ArrayList<List<String>>(BUFFER_SIZE);
+
+    /* Record the refresh period returned from driver */
+    private static long mRefreshPeriod = -1;
+
+    /* Record the size of frame latency */
+    private static int mFrameLatencySampleSize = 0;
+
+    /* An integer array which includes delta vsync */
+    private static long[] mDeltaVsync = new long[BUFFER_SIZE];
+
+    /* Integer array for delta of delta vsync */
+    private static long[] mDelta2Vsync = new long[BUFFER_SIZE];
+
+    /* the maximum delta vsync number */
+    private static long mMaxDeltaVsync;
+
+    /* Normalized data */
+    private static double[] mNormalizedDelta2Vsync = new double[BUFFER_SIZE];
+    private static int[] mRoundNormalizedDelta2Vsync = new int[BUFFER_SIZE];
+
+    /**
+     * Run clear buffer command and clear the saved frame buffer results
+     *
+     * @param windowName the window name that the buffer will be cleared
+     */
+    public static void clearBuffer(String windowName) {
+        // clear results
+        if (mFrameBufferData != null) {
+            mFrameBufferData.clear();
+        }
+        Arrays.fill(mDeltaVsync, -1);
+        Arrays.fill(mDelta2Vsync, -1);
+        Arrays.fill(mNormalizedDelta2Vsync, -1.0);
+        Arrays.fill(mRoundNormalizedDelta2Vsync, -1);
+        mRefreshPeriod = -1;
+        mFrameLatencySampleSize = 0;
+        mMaxDeltaVsync = 0;
+
+        Process p = null;
+        BufferedReader resultReader = null;
+        String command = String.format(CLEAR_BUFFER_CMD, windowName);
+        try {
+            p = Runtime.getRuntime().exec(command);
+            int status = p.waitFor();
+            if (status != 0) {
+                System.err.println(String.format("Run shell command: %s, status: %s",
+                        command, status));
+            }
+        } catch (IOException e) {
+            System.err.println("// Exception from command " + command + ":");
+            System.err.println(e.toString());
+        } catch (InterruptedException e) {
+            System.err.println("// Interrupted while waiting for the command to finish. ");
+            System.err.println(e.toString());
+        } finally {
+            try {
+                if (resultReader != null) {
+                    resultReader.close();
+                }
+                if (p != null) {
+                    p.destroy();
+                }
+            } catch (IOException e) {
+                System.err.println(e.toString());
+            }
+        }
+    }
+
+    /**
+     * Run frame latency command to get the raw data, save raw data on the disk
+     *
+     * @param windowName
+     * @return
+     */
+    public static boolean dumpFrameLatency(String windowName, String fileName, int index) {
+        BufferedWriter fw = null;
+        Process p = null;
+        BufferedReader resultReader = null;
+        String command = String.format(FRAME_LATENCY_CMD, windowName);
+        // if the raw directory doesn't exit, create the directory
+        File rawDataDir = new File(LOCAL_TMP_DIR, RAW_DATA_DIR);
+        try {
+            if (!rawDataDir.exists()) {
+                if (!rawDataDir.mkdir()) {
+                    log(String.format("create directory %s failed, you can manually create " +
+                            "it and start the test again", rawDataDir));
+                    return false;
+                }
+            }
+        } catch (SecurityException e) {
+            System.err.println(e.toString());
+        }
+        String rawFileName = String.format("%s/%s_%d.txt", RAW_DATA_DIR, fileName, index);
+
+        try {
+            p = Runtime.getRuntime().exec(command);
+            int status = p.waitFor();
+            if (status != 0) {
+                System.err.println(String.format("Run shell command: %s, status: %s",
+                        command, status));
+            }
+            resultReader = new BufferedReader(new InputStreamReader(p.getInputStream()));
+            fw = new BufferedWriter(new FileWriter(new File(
+                    LOCAL_TMP_DIR, rawFileName), false));
+            // The first line will always show the refresh period
+            String line = resultReader.readLine();
+            Log.v("testing", "output line = " + line);
+            fw.write(line);
+            fw.write("\n");
+            mRefreshPeriod = Long.parseLong(line.trim());
+            //log("reading refresh period: " + mRefreshPeriod);
+            if (mRefreshPeriod < 0) {
+                return false;
+            }
+
+            while((line = resultReader.readLine()) != null) {
+                fw.write(line);
+                fw.write("\n");
+
+                // remove the last line which is empty
+                if (line.trim().isEmpty()) {
+                    break;
+                }
+                String[] bufferValues = line.split("\\s+");
+                if (bufferValues[0].trim().compareTo("0") == 0) {
+                    continue;
+                }
+                List<String> delayArray = Arrays.asList(bufferValues);
+                mFrameBufferData.add(delayArray);
+                ++mFrameLatencySampleSize;
+            }
+            log("frame latency sample size: " + mFrameLatencySampleSize);
+        } catch (InterruptedException e) {
+            System.err.println("// Exception from command " + command + ":");
+            System.err.println(e.toString());
+        } catch (IOException e) {
+            log("Open file error: " + e.toString());
+            return false;
+        }
+        finally {
+            try {
+                if (resultReader != null) {
+                    resultReader.close();
+                }
+                if (fw != null) {
+                    fw.close();
+                }
+                if (p != null) {
+                    p.destroy();
+                }
+            } catch (IOException e) {
+                System.err.println(e.toString());
+            }
+        }
+        return true;
+    }
+
+    public static long getRefreshPeriod() {
+        if (mRefreshPeriod < 0) {
+            // Haven't dump the frame latency yet
+            log("Run command \"" + FRAME_LATENCY_CMD + " \" before retrieving the refresh period");
+        }
+        return mRefreshPeriod;
+    }
+
+    public static String getFrameBufferData() {
+        if (mFrameBufferData.get(0) == null) {
+            log("Run command \"" + FRAME_LATENCY_CMD + " \" before retrieving frame buffer data");
+            return null;
+        }
+        String rawData = String.format("%d\n", mRefreshPeriod);
+        List<String> tempList = new ArrayList<String>(BUFFER_NUMBER);
+        for (int i = 0; i < mFrameLatencySampleSize; i++) {
+            tempList = mFrameBufferData.get(i);
+            for (int j = 0; j < BUFFER_NUMBER; j++) {
+                rawData += String.format("%s", tempList.get(j));
+                if (j < BUFFER_NUMBER -1) {
+                    rawData += " ";
+                } else {
+                    rawData += "\n";
+                }
+            }
+        }
+        return rawData;
+    }
+
+    /**
+     * Calculate delta(vsync)
+     * @return
+     */
+    public static long[] getDeltaVsync() {
+        if (mRefreshPeriod < 0) {
+            log("Run command \"" + FRAME_LATENCY_CMD + " \" before retrieving frame latency");
+            return null;
+        }
+        if (mDeltaVsync[0] < 0 ) {
+            mDeltaVsync = new long[BUFFER_SIZE];
+            // keep a record of the max DeltaVsync
+            mMaxDeltaVsync = 0;
+            // get the first frame vsync time
+            long preVsyncTime = Long.parseLong(mFrameBufferData.get(0).get(1));
+            for (int i = 1; i < mFrameLatencySampleSize; i++) {
+                long curVsyncTime = Long.parseLong(mFrameBufferData.get(i).get(1));
+                mDeltaVsync[i] = curVsyncTime - preVsyncTime;
+                preVsyncTime = curVsyncTime;
+                if (mMaxDeltaVsync < mDeltaVsync[i]) {
+                    mMaxDeltaVsync = mDeltaVsync[i];
+                }
+            }
+        }
+        return mDeltaVsync;
+    }
+
+    /**
+     * Calculate difference between delta vsync
+     * @return
+     */
+    public static long[] getDelta2Vsync() {
+        if (mRefreshPeriod < 0) {
+            log("Run command \"" + FRAME_LATENCY_CMD + " \" before retrieving frame latency");
+            return null;
+        }
+        if (mDeltaVsync[0] < 0) {
+            getDeltaVsync();
+        }
+        if (mDelta2Vsync[0] < 0) {
+            mDelta2Vsync = new long[BUFFER_SIZE];
+            for (int i = 1; i < mFrameLatencySampleSize; i++) {
+                mDelta2Vsync[i] = mDeltaVsync[i] - mDeltaVsync[i - 1];
+            }
+        }
+        return mDelta2Vsync;
+    }
+
+    /**
+     * normalized delta(delta(vsync)) by refresh period
+     * @return
+     */
+    public static double[] getNormalizedDelta2Vsync() {
+        if (mRefreshPeriod < 0) {
+            log("Run command \"" + FRAME_LATENCY_CMD + " \" before retrieving frame latency");
+            return null;
+        }
+        if (mDelta2Vsync[0] < 0) {
+            getDelta2Vsync();
+        }
+        if (mNormalizedDelta2Vsync[0] < 0) {
+            mNormalizedDelta2Vsync = new double[BUFFER_SIZE];
+            for (int i = 0; i < mFrameLatencySampleSize; i++) {
+                mNormalizedDelta2Vsync[i] = (double)mDelta2Vsync[i] /mRefreshPeriod;
+            }
+        }
+        return mNormalizedDelta2Vsync;
+    }
+
+    public static int[] getRoundNormalizedDelta2Vsync() {
+        if (mRefreshPeriod < 0) {
+            log("Run command \"" + FRAME_LATENCY_CMD + " \" for number of jankiness.");
+            return null;
+        }
+        if (mNormalizedDelta2Vsync[0] < 0) {
+            getNormalizedDelta2Vsync();
+        }
+
+        for (int i = 0; i < mFrameLatencySampleSize; i++) {
+             int value = (int)Math.round(Math.max(mNormalizedDelta2Vsync[i], 0.0));
+             mRoundNormalizedDelta2Vsync[i] = value;
+        }
+        return mRoundNormalizedDelta2Vsync;
+    }
+
+    /*
+     * Get number of jankiness using Vsync time difference
+     */
+    public static int getVsyncJankiness() {
+        if (mRefreshPeriod < 0) {
+            log("Run command \"" + FRAME_LATENCY_CMD + " \" for number of jankiness.");
+            return -1;
+        }
+        if (mRoundNormalizedDelta2Vsync[0] < 0) {
+            getRoundNormalizedDelta2Vsync();
+        }
+        int numberJankiness = 0;
+        for (int i = 0; i < mFrameLatencySampleSize; i++) {
+            int value = mRoundNormalizedDelta2Vsync[i];
+            // ignore the latency which is too long
+            if (value > 0 && value < PAUSE_LATENCY) {
+                numberJankiness++;
+            }
+        }
+        return numberJankiness;
+    }
+
+    /* Track the maximum delta which shows the accumulating time
+     * before animation starts */
+    public static int getMaxDeltaVsync() {
+        return Math.round((float)mMaxDeltaVsync /mRefreshPeriod);
+    }
+
+    /**
+     * Calculate frame rate
+     * @return
+     */
+    public static double getFrameRate() {
+        if (mRefreshPeriod < 0) {
+            log("Run command \"" + FRAME_LATENCY_CMD + " \" before calcuating average frame rate");
+            return -1.0;
+        }
+        if (mFrameBufferData.get(0) == null) {
+            log("Run command \"" + FRAME_LATENCY_CMD + " \" before retrieving frame buffer data");
+            return -1.0;
+        }
+        long startTime = Long.parseLong(mFrameBufferData.get(0).get(1));
+        long endTime =  Long.parseLong(mFrameBufferData.get(mFrameLatencySampleSize - 1).get(1));
+        long totalDuration = endTime - startTime;
+        return (double)((mFrameLatencySampleSize - 1) * Math.pow(10, 9))/totalDuration;
+    }
+
+    /**
+     * Print raw data and processed results into file <testcasename_[iteration]_processed.txt>
+     * @param fileName
+     * @param index
+     */
+    public static void printData(String fileName, int index) {
+        String rawAndProcDataFileName = String.format("%s/%s_%d_processed.txt", RAW_DATA_DIR,
+                fileName, index);
+        log("write raw data and process data into file: " + rawAndProcDataFileName);
+        BufferedWriter fw = null;
+        try {
+            fw = new BufferedWriter(new FileWriter(new File(
+                    LOCAL_TMP_DIR, rawAndProcDataFileName), false));
+            // Show the number of jankiness first:
+            fw.write(String.format("Jankiness count: %d\n", getVsyncJankiness()));
+            fw.write(String.format("Max accumulated frames: %d\n", getMaxDeltaVsync()));
+            fw.write(String.format("Frame rate is: %f\n", getFrameRate()));
+
+            // refresh period
+            fw.write(String.valueOf(mRefreshPeriod));
+            fw.write("\n");
+            fw.write("app\tvsync\tset\tdelta(vsync)\tdelta^2(vsync)\t" +
+                    "delta^2(vsync)/refreshPeriod\t normalized delta^2(vsync)\n");
+
+            for (int i = 0; i < mFrameLatencySampleSize; i++) {
+                // write raw data
+                List<String> rawData = mFrameBufferData.get(i);
+                String line = String.format("%s\t%s\t%s\t%d\t%d\t%f\t%d\n",
+                        rawData.get(0), rawData.get(1), rawData.get(2),
+                        mDeltaVsync[i], mDelta2Vsync[i],
+                        mNormalizedDelta2Vsync[i], mRoundNormalizedDelta2Vsync[i]);
+                fw.write(line);
+            }
+        } catch (IOException e) {
+            log("Open file error: " + e.toString());
+        } finally {
+            try {
+                if (fw != null) {
+                    fw.flush();
+                    fw.close();
+                }
+            }
+            catch (IOException e) {
+                System.err.println(e.toString());
+            }
+        }
+    }
+
+    private static void log(String msg) {
+        Log.v(TAG, msg);
+    }
+}