Merge "Enable debug stuffs" into lmp-preview-dev (aee470c0) · Commits · e / os / android_frameworks_base

core/java/android/view/GLRenderer.java

+16 −23

Original line number	Diff line number	Diff line
		@@ -61,6 +61,7 @@ import android.view.Surface.OutOfResourcesException;

		import com.google.android.gles_jni.EGLImpl;

		import java.io.FileDescriptor;
		import java.io.PrintWriter;
		import java.util.ArrayList;
		import java.util.List;
		@@ -106,7 +107,6 @@ public class GLRenderer extends HardwareRenderer {

		private static final String[] VISUALIZERS = {
		PROFILE_PROPERTY_VISUALIZE_BARS,
		PROFILE_PROPERTY_VISUALIZE_LINES
		};

		private static final String[] OVERDRAW = {
		@@ -674,7 +674,7 @@ public class GLRenderer extends HardwareRenderer {
		mProfilePaint = null;

		if (value) {
		mDebugDataProvider = new DrawPerformanceDataProvider(graphType);
		mDebugDataProvider = new GraphDataProvider(graphType);
		} else {
		mDebugDataProvider = null;
		}
		@@ -742,7 +742,7 @@ public class GLRenderer extends HardwareRenderer {
		}

		@Override
		void dumpGfxInfo(PrintWriter pw) {
		void dumpGfxInfo(PrintWriter pw, FileDescriptor fd) {
		if (mProfileEnabled) {
		pw.printf("\n\tDraw\tProcess\tExecute\n");

		@@ -763,11 +763,6 @@ public class GLRenderer extends HardwareRenderer {
		}
		}

		@Override
		long getFrameCount() {
		return mFrameCount;
		}

		/**
		* Indicates whether this renderer instance can track and update dirty regions.
		*/
		@@ -1446,7 +1441,18 @@ public class GLRenderer extends HardwareRenderer {

		private static native void nPrepareTree(long displayListPtr);

		class DrawPerformanceDataProvider extends GraphDataProvider {
		class GraphDataProvider {
		/**
		* Draws the graph as bars. Frame elements are stacked on top of
		* each other.
		*/
		public static final int GRAPH_TYPE_BARS = 0;
		/**
		* Draws the graph as lines. The number of series drawn corresponds
		* to the number of elements.
		*/
		public static final int GRAPH_TYPE_LINES = 1;

		private final int mGraphType;

		private int mVerticalUnit;
		@@ -1454,11 +1460,10 @@ public class GLRenderer extends HardwareRenderer {
		private int mHorizontalMargin;
		private int mThresholdStroke;

		DrawPerformanceDataProvider(int graphType) {
		public GraphDataProvider(int graphType) {
		mGraphType = graphType;
		}

		@Override
		void prepare(DisplayMetrics metrics) {
		final float density = metrics.density;

		@@ -1468,64 +1473,52 @@ public class GLRenderer extends HardwareRenderer {
		mThresholdStroke = dpToPx(PROFILE_DRAW_THRESHOLD_STROKE_WIDTH, density);
		}

		@Override
		int getGraphType() {
		return mGraphType;
		}

		@Override
		int getVerticalUnitSize() {
		return mVerticalUnit;
		}

		@Override
		int getHorizontalUnitSize() {
		return mHorizontalUnit;
		}

		@Override
		int getHorizontaUnitMargin() {
		return mHorizontalMargin;
		}

		@Override
		float[] getData() {
		return mProfileData;
		}

		@Override
		float getThreshold() {
		return 16;
		}

		@Override
		int getFrameCount() {
		return mProfileData.length / PROFILE_FRAME_DATA_COUNT;
		}

		@Override
		int getElementCount() {
		return PROFILE_FRAME_DATA_COUNT;
		}

		@Override
		int getCurrentFrame() {
		return mProfileCurrentFrame / PROFILE_FRAME_DATA_COUNT;
		}

		@Override
		void setupGraphPaint(Paint paint, int elementIndex) {
		paint.setColor(PROFILE_DRAW_COLORS[elementIndex]);
		if (mGraphType == GRAPH_TYPE_LINES) paint.setStrokeWidth(mThresholdStroke);
		}

		@Override
		void setupThresholdPaint(Paint paint) {
		paint.setColor(PROFILE_DRAW_THRESHOLD_COLOR);
		paint.setStrokeWidth(mThresholdStroke);
		}

		@Override
		void setupCurrentFramePaint(Paint paint) {
		paint.setColor(PROFILE_DRAW_CURRENT_FRAME_COLOR);
		if (mGraphType == GRAPH_TYPE_LINES) paint.setStrokeWidth(mThresholdStroke);

core/java/android/view/HardwareRenderer.java

+2 −114

Original line number	Diff line number	Diff line
		@@ -17,13 +17,13 @@
		package android.view;

		import android.graphics.Bitmap;
		import android.graphics.Paint;
		import android.graphics.Rect;
		import android.graphics.SurfaceTexture;
		import android.util.DisplayMetrics;
		import android.view.Surface.OutOfResourcesException;

		import java.io.File;
		import java.io.FileDescriptor;
		import java.io.PrintWriter;

		/**
		@@ -61,11 +61,9 @@ public abstract class HardwareRenderer {
		* Possible values:
		* "true", to enable profiling
		* "visual_bars", to enable profiling and visualize the results on screen
		* "visual_lines", to enable profiling and visualize the results on screen
		* "false", to disable profiling
		*
		* @see #PROFILE_PROPERTY_VISUALIZE_BARS
		* @see #PROFILE_PROPERTY_VISUALIZE_LINES
		*
		* @hide
		*/
		@@ -79,14 +77,6 @@ public abstract class HardwareRenderer {
		*/
		public static final String PROFILE_PROPERTY_VISUALIZE_BARS = "visual_bars";

		/**
		* Value for {@link #PROFILE_PROPERTY}. When the property is set to this
		* value, profiling data will be visualized on screen as a line chart.
		*
		* @hide
		*/
		public static final String PROFILE_PROPERTY_VISUALIZE_LINES = "visual_lines";

		/**
		* System property used to specify the number of frames to be used
		* when doing hardware rendering profiling.
		@@ -298,16 +288,8 @@ public abstract class HardwareRenderer {

		/**
		* Outputs extra debugging information in the specified file descriptor.
		* @param pw
		*/
		abstract void dumpGfxInfo(PrintWriter pw);

		/**
		* Outputs the total number of frames rendered (used for fps calculations)
		*
		* @return the number of frames rendered
		*/
		abstract long getFrameCount();
		abstract void dumpGfxInfo(PrintWriter pw, FileDescriptor fd);

		/**
		* Loads system properties used by the renderer. This method is invoked
		@@ -583,98 +565,4 @@ public abstract class HardwareRenderer {
		*/
		public void notifyFramePending() {
		}

		/**
		* Describes a series of frames that should be drawn on screen as a graph.
		* Each frame is composed of 1 or more elements.
		*/
		abstract class GraphDataProvider {
		/**
		* Draws the graph as bars. Frame elements are stacked on top of
		* each other.
		*/
		public static final int GRAPH_TYPE_BARS = 0;
		/**
		* Draws the graph as lines. The number of series drawn corresponds
		* to the number of elements.
		*/
		public static final int GRAPH_TYPE_LINES = 1;

		/**
		* Returns the type of graph to render.
		*
		* @return {@link #GRAPH_TYPE_BARS} or {@link #GRAPH_TYPE_LINES}
		*/
		abstract int getGraphType();

		/**
		* This method is invoked before the graph is drawn. This method
		* can be used to compute sizes, etc.
		*
		* @param metrics The display metrics
		*/
		abstract void prepare(DisplayMetrics metrics);

		/**
		* @return The size in pixels of a vertical unit.
		*/
		abstract int getVerticalUnitSize();

		/**
		* @return The size in pixels of a horizontal unit.
		*/
		abstract int getHorizontalUnitSize();

		/**
		* @return The size in pixels of the margin between horizontal units.
		*/
		abstract int getHorizontaUnitMargin();

		/**
		* An optional threshold value.
		*
		* @return A value >= 0 to draw the threshold, a negative value
		* to ignore it.
		*/
		abstract float getThreshold();

		/**
		* The data to draw in the graph. The number of elements in the
		* array must be at least {@link #getFrameCount()} * {@link #getElementCount()}.
		* If a value is negative the following values will be ignored.
		*/
		abstract float[] getData();

		/**
		* Returns the number of frames to render in the graph.
		*/
		abstract int getFrameCount();

		/**
		* Returns the number of elements in each frame. This directly affects
		* the number of series drawn in the graph.
		*/
		abstract int getElementCount();

		/**
		* Returns the current frame, if any. If the returned value is negative
		* the current frame is ignored.
		*/
		abstract int getCurrentFrame();

		/**
		* Prepares the paint to draw the specified element (or series.)
		*/
		abstract void setupGraphPaint(Paint paint, int elementIndex);

		/**
		* Prepares the paint to draw the threshold.
		*/
		abstract void setupThresholdPaint(Paint paint);

		/**
		* Prepares the paint to draw the current frame indicator.
		*/
		abstract void setupCurrentFramePaint(Paint paint);
		}
		}

core/java/android/view/RenderNode.java

+8 −0

Original line number	Diff line number	Diff line
		@@ -850,6 +850,13 @@ public class RenderNode {
		nOutput(mNativeRenderNode);
		}

		/**
		* Gets the size of the DisplayList for debug purposes.
		*/
		public int getDebugSize() {
		return nGetDebugSize(mNativeRenderNode);
		}

		///////////////////////////////////////////////////////////////////////////
		// Animations
		///////////////////////////////////////////////////////////////////////////
		@@ -941,6 +948,7 @@ public class RenderNode {
		private static native float nGetPivotX(long renderNode);
		private static native float nGetPivotY(long renderNode);
		private static native void nOutput(long renderNode);
		private static native int nGetDebugSize(long renderNode);

		///////////////////////////////////////////////////////////////////////////
		// Animations

core/java/android/view/ThreadedRenderer.java

+44 −8

Original line number	Diff line number	Diff line
		@@ -22,12 +22,14 @@ import android.graphics.SurfaceTexture;
		import android.os.IBinder;
		import android.os.RemoteException;
		import android.os.ServiceManager;
		import android.os.SystemProperties;
		import android.os.Trace;
		import android.util.Log;
		import android.util.TimeUtils;
		import android.view.Surface.OutOfResourcesException;
		import android.view.View.AttachInfo;

		import java.io.FileDescriptor;
		import java.io.PrintWriter;

		/**
		@@ -60,11 +62,16 @@ public class ThreadedRenderer extends HardwareRenderer {
		// Needs a ViewRoot invalidate
		private static final int SYNC_INVALIDATE_REQUIRED = 0x1;

		private static final String[] VISUALIZERS = {
		PROFILE_PROPERTY_VISUALIZE_BARS,
		};

		private int mWidth, mHeight;
		private long mNativeProxy;
		private boolean mInitialized = false;
		private RenderNode mRootNode;
		private Choreographer mChoreographer;
		private boolean mProfilingEnabled;

		ThreadedRenderer(boolean translucent) {
		AtlasInitializer.sInstance.init();
		@@ -77,6 +84,8 @@ public class ThreadedRenderer extends HardwareRenderer {
		// Setup timing
		mChoreographer = Choreographer.getInstance();
		nSetFrameInterval(mNativeProxy, mChoreographer.getFrameIntervalNanos());

		loadSystemProperties();
		}

		@Override
		@@ -166,19 +175,33 @@ public class ThreadedRenderer extends HardwareRenderer {
		}

		@Override
		void dumpGfxInfo(PrintWriter pw) {
		// TODO Auto-generated method stub
		void dumpGfxInfo(PrintWriter pw, FileDescriptor fd) {
		pw.flush();
		nDumpProfileInfo(mNativeProxy, fd);
		}

		@Override
		long getFrameCount() {
		// TODO Auto-generated method stub
		return 0;
		private static int search(String[] values, String value) {
		for (int i = 0; i < values.length; i++) {
		if (values[i].equals(value)) return i;
		}
		return -1;
		}

		private static boolean checkIfProfilingRequested() {
		String profiling = SystemProperties.get(HardwareRenderer.PROFILE_PROPERTY);
		int graphType = search(VISUALIZERS, profiling);
		return (graphType >= 0) \|\| Boolean.parseBoolean(profiling);
		}

		@Override
		boolean loadSystemProperties() {
		return nLoadSystemProperties(mNativeProxy);
		boolean changed = nLoadSystemProperties(mNativeProxy);
		boolean wantProfiling = checkIfProfilingRequested();
		if (wantProfiling != mProfilingEnabled) {
		mProfilingEnabled = wantProfiling;
		changed = true;
		}
		return changed;
		}

		private void updateRootDisplayList(View view, HardwareDrawCallbacks callbacks) {
		@@ -210,14 +233,24 @@ public class ThreadedRenderer extends HardwareRenderer {
		long frameTimeNanos = mChoreographer.getFrameTimeNanos();
		attachInfo.mDrawingTime = frameTimeNanos / TimeUtils.NANOS_PER_MS;

		long recordDuration = 0;
		if (mProfilingEnabled) {
		recordDuration = System.nanoTime();
		}

		updateRootDisplayList(view, callbacks);

		if (mProfilingEnabled) {
		recordDuration = System.nanoTime() - recordDuration;
		}

		attachInfo.mIgnoreDirtyState = false;

		if (dirty == null) {
		dirty = NULL_RECT;
		}
		int syncResult = nSyncAndDrawFrame(mNativeProxy, frameTimeNanos,
		recordDuration, view.getResources().getDisplayMetrics().density,
		dirty.left, dirty.top, dirty.right, dirty.bottom);
		if ((syncResult & SYNC_INVALIDATE_REQUIRED) != 0) {
		attachInfo.mViewRootImpl.invalidate();
		@@ -354,7 +387,8 @@ public class ThreadedRenderer extends HardwareRenderer {
		private static native void nSetup(long nativeProxy, int width, int height,
		float lightX, float lightY, float lightZ, float lightRadius);
		private static native void nSetOpaque(long nativeProxy, boolean opaque);
		private static native int nSyncAndDrawFrame(long nativeProxy, long frameTimeNanos,
		private static native int nSyncAndDrawFrame(long nativeProxy,
		long frameTimeNanos, long recordDuration, float density,
		int dirtyLeft, int dirtyTop, int dirtyRight, int dirtyBottom);
		private static native void nRunWithGlContext(long nativeProxy, Runnable runnable);
		private static native void nDestroyCanvasAndSurface(long nativeProxy);
		@@ -370,4 +404,6 @@ public class ThreadedRenderer extends HardwareRenderer {

		private static native void nFence(long nativeProxy);
		private static native void nNotifyFramePending(long nativeProxy);

		private static native void nDumpProfileInfo(long nativeProxy, FileDescriptor fd);
		}

core/java/android/view/ViewRootImpl.java

+1 −1

Original line number	Diff line number	Diff line
		@@ -5329,7 +5329,7 @@ public final class ViewRootImpl implements ViewParent,
		RenderNode renderNode = view.mRenderNode;
		info[0]++;
		if (renderNode != null) {
		info[1] += 0; /* TODO: Memory used by RenderNodes (properties + DisplayLists) */
		info[1] += renderNode.getDebugSize();
		}

		if (view instanceof ViewGroup) {