tests/UiBench/src/com/android/test/uibench/RenderingJitter.java - platform/frameworks/base - Git at Google

 /*
  * 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.test.uibench;

 import android.app.Activity;
 import android.content.Context;
 import android.graphics.Canvas;
 import android.graphics.Color;
 import android.graphics.ColorFilter;
 import android.graphics.Paint;
 import android.graphics.PixelFormat;
 import android.graphics.Rect;
 import android.graphics.drawable.Drawable;
 import android.os.Bundle;
 import android.os.Handler;
 import android.os.HandlerThread;
 import android.os.Message;
 import android.util.AttributeSet;
 import android.view.FrameMetrics;
 import android.view.View;
 import android.view.Window;
 import android.view.Window.OnFrameMetricsAvailableListener;
 import android.view.animation.AnimationUtils;
 import android.widget.TextView;

 public class RenderingJitter extends Activity {
     private TextView mJitterReport;
     private TextView mUiFrameTimeReport;
     private TextView mRenderThreadTimeReport;
     private TextView mTotalFrameTimeReport;
     private TextView mMostlyTotalFrameTimeReport;
     private PointGraphView mGraph;

     private static Handler sMetricsHandler;
     static {
         HandlerThread thread = new HandlerThread("frameMetricsListener");
         thread.start();
         sMetricsHandler = new Handler(thread.getLooper());
     }

     private Handler mUpdateHandler = new Handler() {
         @Override
         public void handleMessage(Message msg) {
             switch (msg.what) {
                 case R.id.jitter_mma:
                     mJitterReport.setText((CharSequence) msg.obj);
                     break;
                 case R.id.totalish_mma:
                     mMostlyTotalFrameTimeReport.setText((CharSequence) msg.obj);
                     break;
                 case R.id.ui_frametime_mma:
                     mUiFrameTimeReport.setText((CharSequence) msg.obj);
                     break;
                 case R.id.rt_frametime_mma:
                     mRenderThreadTimeReport.setText((CharSequence) msg.obj);
                     break;
                 case R.id.total_mma:
                     mTotalFrameTimeReport.setText((CharSequence) msg.obj);
                     break;
                 case R.id.graph:
                     mGraph.addJitterSample(msg.arg1, msg.arg2);
                     break;
             }
         }
     };

     @Override
     protected void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
         setContentView(R.layout.rendering_jitter);
         View content = findViewById(android.R.id.content);
         content.setBackground(new AnimatedBackgroundDrawable());
         content.setKeepScreenOn(true);
         mJitterReport = findViewById(R.id.jitter_mma);
         mMostlyTotalFrameTimeReport = findViewById(R.id.totalish_mma);
         mUiFrameTimeReport = findViewById(R.id.ui_frametime_mma);
         mRenderThreadTimeReport = findViewById(R.id.rt_frametime_mma);
         mTotalFrameTimeReport = findViewById(R.id.total_mma);
         mGraph = findViewById(R.id.graph);
         mJitterReport.setText("abcdefghijklmnopqrstuvwxyz");
         mMostlyTotalFrameTimeReport.setText("ABCDEFGHIJKLMNOPQRSTUVWXYZ");
         mUiFrameTimeReport.setText("0123456789");
         mRenderThreadTimeReport.setText(",.!()[]{};");
         getWindow().addOnFrameMetricsAvailableListener(mMetricsListener, sMetricsHandler);
     }

     public static final class PointGraphView extends View {
         private static final float[] JITTER_LINES_MS = {
                 .5f, 1.0f, 1.5f, 2.0f, 3.0f, 4.0f, 5.0f
         };
         private static final String[] JITTER_LINES_LABELS = makeLabels(JITTER_LINES_MS);
         private static final int[] JITTER_LINES_COLORS = new int[] {
                 0xFF00E676, 0xFFFFF176, 0xFFFDD835, 0xFFFBC02D, 0xFFF9A825,
                 0xFFF57F17, 0xFFDD2C00
         };
         private Paint mPaint = new Paint();
         private float[] mJitterYs = new float[JITTER_LINES_MS.length];
         private float mLabelWidth;
         private float mLabelHeight;
         private float mDensity;
         private float mGraphScale;
         private float mGraphMaxMs;

         private float[] mJitterPoints;
         private float[] mJitterAvgPoints;

         public PointGraphView(Context context, AttributeSet attrs) {
             super(context, attrs);
             setWillNotDraw(false);
             mDensity = context.getResources().getDisplayMetrics().density;
             mPaint.setTextSize(dp(10));
             Rect textBounds = new Rect();
             mPaint.getTextBounds("8.8", 0, 3, textBounds);
             mLabelWidth = textBounds.width() + dp(2);
             mLabelHeight = textBounds.height();
         }

         public void addJitterSample(int jitterUs, int jitterUsAvg) {
             for (int i = 1; i < mJitterPoints.length - 2; i += 2) {
                 mJitterPoints[i] = mJitterPoints[i + 2];
                 mJitterAvgPoints[i] = mJitterAvgPoints[i + 2];
             }
             mJitterPoints[mJitterPoints.length - 1] =
                     getHeight() - mGraphScale * (jitterUs / 1000.0f);
             mJitterAvgPoints[mJitterAvgPoints.length - 1] =
                     getHeight() - mGraphScale * (jitterUsAvg / 1000.0f);
             invalidate();
         }

         private float dp(float dp) {
             return mDensity * dp;
         }

         @Override
         protected void onDraw(Canvas canvas) {
             canvas.drawColor(0x90000000);
             int h = getHeight();
             int w = getWidth();
             mPaint.setColor(Color.WHITE);
             mPaint.setStrokeWidth(dp(1));
             canvas.drawLine(mLabelWidth, 0, mLabelWidth, h, mPaint);
             for (int i = 0; i < JITTER_LINES_LABELS.length; i++) {
                 canvas.drawText(JITTER_LINES_LABELS[i],
                         0, (float) Math.floor(mJitterYs[i] + mLabelHeight * .5f), mPaint);
             }
             for (int i = 0; i < JITTER_LINES_LABELS.length; i++) {
                 mPaint.setColor(JITTER_LINES_COLORS[i]);
                 canvas.drawLine(mLabelWidth, mJitterYs[i], w, mJitterYs[i], mPaint);
             }
             mPaint.setStrokeWidth(dp(2));
             mPaint.setColor(Color.WHITE);
             canvas.drawPoints(mJitterPoints, mPaint);
             mPaint.setColor(0xFF2196F3);
             canvas.drawPoints(mJitterAvgPoints, mPaint);
         }

         @Override
         protected void onSizeChanged(int w, int h, int oldw, int oldh) {
             super.onSizeChanged(w, h, oldw, oldh);
             int graphWidth = (int) ((w - mLabelWidth - dp(1)) / mDensity);
             float[] oldJitterPoints = mJitterPoints;
             float[] oldJitterAvgPoints = mJitterAvgPoints;
             mJitterPoints = new float[graphWidth * 2];
             mJitterAvgPoints = new float[graphWidth * 2];
             for (int i = 0; i < mJitterPoints.length; i += 2) {
                 mJitterPoints[i] = mLabelWidth + (i / 2 + 1) * mDensity;
                 mJitterAvgPoints[i] = mJitterPoints[i];
             }
             if (oldJitterPoints != null) {
                 int newIndexShift = Math.max(mJitterPoints.length - oldJitterPoints.length, 0);
                 int oldIndexShift = oldJitterPoints.length - mJitterPoints.length;
                 for (int i = 1 + newIndexShift; i < mJitterPoints.length; i += 2) {
                     mJitterPoints[i] = oldJitterPoints[i + oldIndexShift];
                     mJitterAvgPoints[i] = oldJitterAvgPoints[i + oldIndexShift];
                 }
             }
             mGraphMaxMs = JITTER_LINES_MS[JITTER_LINES_MS.length - 1] + .5f;
             mGraphScale = (h / mGraphMaxMs);
             for (int i = 0; i < JITTER_LINES_MS.length; i++) {
                 mJitterYs[i] = (float) Math.floor(h - mGraphScale * JITTER_LINES_MS[i]);
             }
         }

         private static String[] makeLabels(float[] divisions) {
             String[] ret = new String[divisions.length];
             for (int i = 0; i < divisions.length; i++) {
                 ret[i] = Float.toString(divisions[i]);
             }
             return ret;
         }
     }

     private final OnFrameMetricsAvailableListener mMetricsListener = new OnFrameMetricsAvailableListener() {
         private final static double WEIGHT = 40;
         private long mPreviousFrameTotal;
         private double mJitterMma;
         private double mUiFrametimeMma;
         private double mRtFrametimeMma;
         private double mTotalFrametimeMma;
         private double mMostlyTotalFrametimeMma;
         private boolean mNeedsFirstValues = true;

         @Override
         public void onFrameMetricsAvailable(Window window, FrameMetrics frameMetrics,
                 int dropCountSinceLastInvocation) {
             if (frameMetrics.getMetric(FrameMetrics.FIRST_DRAW_FRAME) == 1) {
                 return;
             }

             long uiDuration = frameMetrics.getMetric(FrameMetrics.INPUT_HANDLING_DURATION)
                     + frameMetrics.getMetric(FrameMetrics.ANIMATION_DURATION)
                     + frameMetrics.getMetric(FrameMetrics.LAYOUT_MEASURE_DURATION)
                     + frameMetrics.getMetric(FrameMetrics.DRAW_DURATION);
             long rtDuration = frameMetrics.getMetric(FrameMetrics.SYNC_DURATION)
                     + frameMetrics.getMetric(FrameMetrics.COMMAND_ISSUE_DURATION);
             long totalDuration = frameMetrics.getMetric(FrameMetrics.TOTAL_DURATION);
             long jitter = Math.abs(totalDuration - mPreviousFrameTotal);
             if (mNeedsFirstValues) {
                 mJitterMma = 0;
                 mUiFrametimeMma = uiDuration;
                 mRtFrametimeMma = rtDuration;
                 mTotalFrametimeMma = totalDuration;
                 mMostlyTotalFrametimeMma = uiDuration + rtDuration;
                 mNeedsFirstValues = false;
             } else {
                 mJitterMma = add(mJitterMma, jitter);
                 mUiFrametimeMma = add(mUiFrametimeMma, uiDuration);
                 mRtFrametimeMma = add(mRtFrametimeMma, rtDuration);
                 mTotalFrametimeMma = add(mTotalFrametimeMma, totalDuration);
                 mMostlyTotalFrametimeMma = add(mMostlyTotalFrametimeMma, uiDuration + rtDuration);
             }
             mPreviousFrameTotal = totalDuration;
             mUpdateHandler.obtainMessage(R.id.jitter_mma,
                     String.format("Jitter: %.3fms", toMs(mJitterMma))).sendToTarget();
             mUpdateHandler.obtainMessage(R.id.totalish_mma,
                     String.format("CPU-total duration: %.3fms", toMs(mMostlyTotalFrametimeMma))).sendToTarget();
             mUpdateHandler.obtainMessage(R.id.ui_frametime_mma,
                     String.format("UI duration: %.3fms", toMs(mUiFrametimeMma))).sendToTarget();
             mUpdateHandler.obtainMessage(R.id.rt_frametime_mma,
                     String.format("RT duration: %.3fms", toMs(mRtFrametimeMma))).sendToTarget();
             mUpdateHandler.obtainMessage(R.id.total_mma,
                     String.format("Total duration: %.3fms", toMs(mTotalFrametimeMma))).sendToTarget();
             mUpdateHandler.obtainMessage(R.id.graph, (int) (jitter / 1000),
                     (int) (mJitterMma / 1000)).sendToTarget();
         }

         double add(double previous, double today) {
             return (((WEIGHT - 1) * previous) + today) / WEIGHT;
         }

         double toMs(double val) {
             return val / 1000000;
         }
     };

     private static final class AnimatedBackgroundDrawable extends Drawable {
         private static final int FROM_COLOR = 0xFF18FFFF;
         private static final int TO_COLOR = 0xFF40C4FF;
         private static final int DURATION = 1400;

         private final Paint mPaint;
         private boolean mReverse;
         private long mStartTime;
         private int mColor;

         private boolean mReverseX;
         private boolean mReverseY;
         private float mX;
         private float mY;
         private float mRadius;
         private float mMoveStep = 10.0f;

         public AnimatedBackgroundDrawable() {
             mPaint = new Paint();
             mPaint.setColor(0xFFFFFF00);
             mPaint.setAntiAlias(true);
         }

         @Override
         public void draw(Canvas canvas) {
             stepColor();
             canvas.drawColor(mColor);

             mX += (mReverseX ? -mMoveStep : mMoveStep);
             mY += (mReverseY ? -mMoveStep : mMoveStep);
             clampXY();
             canvas.drawCircle(mX, mY, mRadius, mPaint);

             invalidateSelf();
         }

         private void clampXY() {
             if (mX <= mRadius) {
                 mReverseX = false;
                 mX = mRadius;
             }
             if (mY <= mRadius) {
                 mReverseY = false;
                 mY = mRadius;
             }
             float maxX = getBounds().width() - mRadius;
             if (mX >= maxX) {
                 mReverseX = true;
                 mX = maxX;
             }
             float maxY = getBounds().height() - mRadius;
             if (mY >= maxY) {
                 mReverseY = true;
                 mY = maxY;
             }
         }

         @Override
         protected void onBoundsChange(Rect bounds) {
             super.onBoundsChange(bounds);
             mMoveStep = Math.min(bounds.width(), bounds.height()) / 130.0f;
             mRadius = Math.min(bounds.width(), bounds.height()) / 20.0f;
         }

         @Override
         public void setAlpha(int alpha) {
         }

         @Override
         public void setColorFilter(ColorFilter colorFilter) {
         }

         @Override
         public int getOpacity() {
             return PixelFormat.OPAQUE;
         }

         private void stepColor() {
             if (mStartTime == 0) {
                 mStartTime = AnimationUtils.currentAnimationTimeMillis();
             }
             float frac = (AnimationUtils.currentAnimationTimeMillis() - mStartTime)
                     / (float) DURATION;
             if (frac > 1.0f) frac = 1.0f;
             int dest = mReverse ? FROM_COLOR : TO_COLOR;
             int src = mReverse ? TO_COLOR : FROM_COLOR;
             int r = (int) (Color.red(src) + (Color.red(dest) - Color.red(src)) * frac);
             int g = (int) (Color.green(src) + (Color.green(dest) - Color.green(src)) * frac);
             int b = (int) (Color.blue(src) + (Color.blue(dest) - Color.blue(src)) * frac);
             mColor = Color.rgb(r, g, b);
             if (frac == 1.0f) {
                 mStartTime = 0;
                 mReverse = !mReverse;
             }
         }
     }
 }
	/*
	* 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.test.uibench;

	import android.app.Activity;
	import android.content.Context;
	import android.graphics.Canvas;
	import android.graphics.Color;
	import android.graphics.ColorFilter;
	import android.graphics.Paint;
	import android.graphics.PixelFormat;
	import android.graphics.Rect;
	import android.graphics.drawable.Drawable;
	import android.os.Bundle;
	import android.os.Handler;
	import android.os.HandlerThread;
	import android.os.Message;
	import android.util.AttributeSet;
	import android.view.FrameMetrics;
	import android.view.View;
	import android.view.Window;
	import android.view.Window.OnFrameMetricsAvailableListener;
	import android.view.animation.AnimationUtils;
	import android.widget.TextView;

	public class RenderingJitter extends Activity {
	private TextView mJitterReport;
	private TextView mUiFrameTimeReport;
	private TextView mRenderThreadTimeReport;
	private TextView mTotalFrameTimeReport;
	private TextView mMostlyTotalFrameTimeReport;
	private PointGraphView mGraph;

	private static Handler sMetricsHandler;
	static {
	HandlerThread thread = new HandlerThread("frameMetricsListener");
	thread.start();
	sMetricsHandler = new Handler(thread.getLooper());
	}

	private Handler mUpdateHandler = new Handler() {
	@Override
	public void handleMessage(Message msg) {
	switch (msg.what) {
	case R.id.jitter_mma:
	mJitterReport.setText((CharSequence) msg.obj);
	break;
	case R.id.totalish_mma:
	mMostlyTotalFrameTimeReport.setText((CharSequence) msg.obj);
	break;
	case R.id.ui_frametime_mma:
	mUiFrameTimeReport.setText((CharSequence) msg.obj);
	break;
	case R.id.rt_frametime_mma:
	mRenderThreadTimeReport.setText((CharSequence) msg.obj);
	break;
	case R.id.total_mma:
	mTotalFrameTimeReport.setText((CharSequence) msg.obj);
	break;
	case R.id.graph:
	mGraph.addJitterSample(msg.arg1, msg.arg2);
	break;
	}
	}
	};

	@Override
	protected void onCreate(Bundle savedInstanceState) {
	super.onCreate(savedInstanceState);
	setContentView(R.layout.rendering_jitter);
	View content = findViewById(android.R.id.content);
	content.setBackground(new AnimatedBackgroundDrawable());
	content.setKeepScreenOn(true);
	mJitterReport = findViewById(R.id.jitter_mma);
	mMostlyTotalFrameTimeReport = findViewById(R.id.totalish_mma);
	mUiFrameTimeReport = findViewById(R.id.ui_frametime_mma);
	mRenderThreadTimeReport = findViewById(R.id.rt_frametime_mma);
	mTotalFrameTimeReport = findViewById(R.id.total_mma);
	mGraph = findViewById(R.id.graph);
	mJitterReport.setText("abcdefghijklmnopqrstuvwxyz");
	mMostlyTotalFrameTimeReport.setText("ABCDEFGHIJKLMNOPQRSTUVWXYZ");
	mUiFrameTimeReport.setText("0123456789");
	mRenderThreadTimeReport.setText(",.!()[]{};");
	getWindow().addOnFrameMetricsAvailableListener(mMetricsListener, sMetricsHandler);
	}

	public static final class PointGraphView extends View {
	private static final float[] JITTER_LINES_MS = {
	.5f, 1.0f, 1.5f, 2.0f, 3.0f, 4.0f, 5.0f
	};
	private static final String[] JITTER_LINES_LABELS = makeLabels(JITTER_LINES_MS);
	private static final int[] JITTER_LINES_COLORS = new int[] {
	0xFF00E676, 0xFFFFF176, 0xFFFDD835, 0xFFFBC02D, 0xFFF9A825,
	0xFFF57F17, 0xFFDD2C00
	};
	private Paint mPaint = new Paint();
	private float[] mJitterYs = new float[JITTER_LINES_MS.length];
	private float mLabelWidth;
	private float mLabelHeight;
	private float mDensity;
	private float mGraphScale;
	private float mGraphMaxMs;

	private float[] mJitterPoints;
	private float[] mJitterAvgPoints;

	public PointGraphView(Context context, AttributeSet attrs) {
	super(context, attrs);
	setWillNotDraw(false);
	mDensity = context.getResources().getDisplayMetrics().density;
	mPaint.setTextSize(dp(10));
	Rect textBounds = new Rect();
	mPaint.getTextBounds("8.8", 0, 3, textBounds);
	mLabelWidth = textBounds.width() + dp(2);
	mLabelHeight = textBounds.height();
	}

	public void addJitterSample(int jitterUs, int jitterUsAvg) {
	for (int i = 1; i < mJitterPoints.length - 2; i += 2) {
	mJitterPoints[i] = mJitterPoints[i + 2];
	mJitterAvgPoints[i] = mJitterAvgPoints[i + 2];
	}
	mJitterPoints[mJitterPoints.length - 1] =
	getHeight() - mGraphScale * (jitterUs / 1000.0f);
	mJitterAvgPoints[mJitterAvgPoints.length - 1] =
	getHeight() - mGraphScale * (jitterUsAvg / 1000.0f);
	invalidate();
	}

	private float dp(float dp) {
	return mDensity * dp;
	}

	@Override
	protected void onDraw(Canvas canvas) {
	canvas.drawColor(0x90000000);
	int h = getHeight();
	int w = getWidth();
	mPaint.setColor(Color.WHITE);
	mPaint.setStrokeWidth(dp(1));
	canvas.drawLine(mLabelWidth, 0, mLabelWidth, h, mPaint);
	for (int i = 0; i < JITTER_LINES_LABELS.length; i++) {
	canvas.drawText(JITTER_LINES_LABELS[i],
	0, (float) Math.floor(mJitterYs[i] + mLabelHeight * .5f), mPaint);
	}
	for (int i = 0; i < JITTER_LINES_LABELS.length; i++) {
	mPaint.setColor(JITTER_LINES_COLORS[i]);
	canvas.drawLine(mLabelWidth, mJitterYs[i], w, mJitterYs[i], mPaint);
	}
	mPaint.setStrokeWidth(dp(2));
	mPaint.setColor(Color.WHITE);
	canvas.drawPoints(mJitterPoints, mPaint);
	mPaint.setColor(0xFF2196F3);
	canvas.drawPoints(mJitterAvgPoints, mPaint);
	}

	@Override
	protected void onSizeChanged(int w, int h, int oldw, int oldh) {
	super.onSizeChanged(w, h, oldw, oldh);
	int graphWidth = (int) ((w - mLabelWidth - dp(1)) / mDensity);
	float[] oldJitterPoints = mJitterPoints;
	float[] oldJitterAvgPoints = mJitterAvgPoints;
	mJitterPoints = new float[graphWidth * 2];
	mJitterAvgPoints = new float[graphWidth * 2];
	for (int i = 0; i < mJitterPoints.length; i += 2) {
	mJitterPoints[i] = mLabelWidth + (i / 2 + 1) * mDensity;
	mJitterAvgPoints[i] = mJitterPoints[i];
	}
	if (oldJitterPoints != null) {
	int newIndexShift = Math.max(mJitterPoints.length - oldJitterPoints.length, 0);
	int oldIndexShift = oldJitterPoints.length - mJitterPoints.length;
	for (int i = 1 + newIndexShift; i < mJitterPoints.length; i += 2) {
	mJitterPoints[i] = oldJitterPoints[i + oldIndexShift];
	mJitterAvgPoints[i] = oldJitterAvgPoints[i + oldIndexShift];
	}
	}
	mGraphMaxMs = JITTER_LINES_MS[JITTER_LINES_MS.length - 1] + .5f;
	mGraphScale = (h / mGraphMaxMs);
	for (int i = 0; i < JITTER_LINES_MS.length; i++) {
	mJitterYs[i] = (float) Math.floor(h - mGraphScale * JITTER_LINES_MS[i]);
	}
	}

	private static String[] makeLabels(float[] divisions) {
	String[] ret = new String[divisions.length];
	for (int i = 0; i < divisions.length; i++) {
	ret[i] = Float.toString(divisions[i]);
	}
	return ret;
	}
	}

	private final OnFrameMetricsAvailableListener mMetricsListener = new OnFrameMetricsAvailableListener() {
	private final static double WEIGHT = 40;
	private long mPreviousFrameTotal;
	private double mJitterMma;
	private double mUiFrametimeMma;
	private double mRtFrametimeMma;
	private double mTotalFrametimeMma;
	private double mMostlyTotalFrametimeMma;
	private boolean mNeedsFirstValues = true;

	@Override
	public void onFrameMetricsAvailable(Window window, FrameMetrics frameMetrics,
	int dropCountSinceLastInvocation) {
	if (frameMetrics.getMetric(FrameMetrics.FIRST_DRAW_FRAME) == 1) {
	return;
	}

	long uiDuration = frameMetrics.getMetric(FrameMetrics.INPUT_HANDLING_DURATION)
	+ frameMetrics.getMetric(FrameMetrics.ANIMATION_DURATION)
	+ frameMetrics.getMetric(FrameMetrics.LAYOUT_MEASURE_DURATION)
	+ frameMetrics.getMetric(FrameMetrics.DRAW_DURATION);
	long rtDuration = frameMetrics.getMetric(FrameMetrics.SYNC_DURATION)
	+ frameMetrics.getMetric(FrameMetrics.COMMAND_ISSUE_DURATION);
	long totalDuration = frameMetrics.getMetric(FrameMetrics.TOTAL_DURATION);
	long jitter = Math.abs(totalDuration - mPreviousFrameTotal);
	if (mNeedsFirstValues) {
	mJitterMma = 0;
	mUiFrametimeMma = uiDuration;
	mRtFrametimeMma = rtDuration;
	mTotalFrametimeMma = totalDuration;
	mMostlyTotalFrametimeMma = uiDuration + rtDuration;
	mNeedsFirstValues = false;
	} else {
	mJitterMma = add(mJitterMma, jitter);
	mUiFrametimeMma = add(mUiFrametimeMma, uiDuration);
	mRtFrametimeMma = add(mRtFrametimeMma, rtDuration);
	mTotalFrametimeMma = add(mTotalFrametimeMma, totalDuration);
	mMostlyTotalFrametimeMma = add(mMostlyTotalFrametimeMma, uiDuration + rtDuration);
	}
	mPreviousFrameTotal = totalDuration;
	mUpdateHandler.obtainMessage(R.id.jitter_mma,
	String.format("Jitter: %.3fms", toMs(mJitterMma))).sendToTarget();
	mUpdateHandler.obtainMessage(R.id.totalish_mma,
	String.format("CPU-total duration: %.3fms", toMs(mMostlyTotalFrametimeMma))).sendToTarget();
	mUpdateHandler.obtainMessage(R.id.ui_frametime_mma,
	String.format("UI duration: %.3fms", toMs(mUiFrametimeMma))).sendToTarget();
	mUpdateHandler.obtainMessage(R.id.rt_frametime_mma,
	String.format("RT duration: %.3fms", toMs(mRtFrametimeMma))).sendToTarget();
	mUpdateHandler.obtainMessage(R.id.total_mma,
	String.format("Total duration: %.3fms", toMs(mTotalFrametimeMma))).sendToTarget();
	mUpdateHandler.obtainMessage(R.id.graph, (int) (jitter / 1000),
	(int) (mJitterMma / 1000)).sendToTarget();
	}

	double add(double previous, double today) {
	return (((WEIGHT - 1) * previous) + today) / WEIGHT;
	}

	double toMs(double val) {
	return val / 1000000;
	}
	};

	private static final class AnimatedBackgroundDrawable extends Drawable {
	private static final int FROM_COLOR = 0xFF18FFFF;
	private static final int TO_COLOR = 0xFF40C4FF;
	private static final int DURATION = 1400;

	private final Paint mPaint;
	private boolean mReverse;
	private long mStartTime;
	private int mColor;

	private boolean mReverseX;
	private boolean mReverseY;
	private float mX;
	private float mY;
	private float mRadius;
	private float mMoveStep = 10.0f;

	public AnimatedBackgroundDrawable() {
	mPaint = new Paint();
	mPaint.setColor(0xFFFFFF00);
	mPaint.setAntiAlias(true);
	}

	@Override
	public void draw(Canvas canvas) {
	stepColor();
	canvas.drawColor(mColor);

	mX += (mReverseX ? -mMoveStep : mMoveStep);
	mY += (mReverseY ? -mMoveStep : mMoveStep);
	clampXY();
	canvas.drawCircle(mX, mY, mRadius, mPaint);

	invalidateSelf();
	}

	private void clampXY() {
	if (mX <= mRadius) {
	mReverseX = false;
	mX = mRadius;
	}
	if (mY <= mRadius) {
	mReverseY = false;
	mY = mRadius;
	}
	float maxX = getBounds().width() - mRadius;
	if (mX >= maxX) {
	mReverseX = true;
	mX = maxX;
	}
	float maxY = getBounds().height() - mRadius;
	if (mY >= maxY) {
	mReverseY = true;
	mY = maxY;
	}
	}

	@Override
	protected void onBoundsChange(Rect bounds) {
	super.onBoundsChange(bounds);
	mMoveStep = Math.min(bounds.width(), bounds.height()) / 130.0f;
	mRadius = Math.min(bounds.width(), bounds.height()) / 20.0f;
	}

	@Override
	public void setAlpha(int alpha) {
	}

	@Override
	public void setColorFilter(ColorFilter colorFilter) {
	}

	@Override
	public int getOpacity() {
	return PixelFormat.OPAQUE;
	}

	private void stepColor() {
	if (mStartTime == 0) {
	mStartTime = AnimationUtils.currentAnimationTimeMillis();
	}
	float frac = (AnimationUtils.currentAnimationTimeMillis() - mStartTime)
	/ (float) DURATION;
	if (frac > 1.0f) frac = 1.0f;
	int dest = mReverse ? FROM_COLOR : TO_COLOR;
	int src = mReverse ? TO_COLOR : FROM_COLOR;
	int r = (int) (Color.red(src) + (Color.red(dest) - Color.red(src)) * frac);
	int g = (int) (Color.green(src) + (Color.green(dest) - Color.green(src)) * frac);
	int b = (int) (Color.blue(src) + (Color.blue(dest) - Color.blue(src)) * frac);
	mColor = Color.rgb(r, g, b);
	if (frac == 1.0f) {
	mStartTime = 0;
	mReverse = !mReverse;
	}
	}
	}
	}