Merge "Remove HardwareCanvas" (43c410ea) · Commits · e / os / android_frameworks_base

core/java/android/view/DisplayListCanvas.java

+54 −8

Original line number	Original line	Diff line number	Diff line
	@@ -18,6 +18,7 @@ package android.view;

	import android.annotation.NonNull;		import android.annotation.NonNull;
	import android.graphics.Bitmap;		import android.graphics.Bitmap;
			import android.graphics.Canvas;
	import android.graphics.CanvasProperty;		import android.graphics.CanvasProperty;
	import android.graphics.NinePatch;		import android.graphics.NinePatch;
	import android.graphics.Paint;		import android.graphics.Paint;
	@@ -32,8 +33,10 @@ import android.util.Pools.SynchronizedPool;
	* This is intended for use with a DisplayList. This class keeps a list of all the Paint and		* This is intended for use with a DisplayList. This class keeps a list of all the Paint and
	* Bitmap objects that it draws, preventing the backing memory of Bitmaps from being freed while		* Bitmap objects that it draws, preventing the backing memory of Bitmaps from being freed while
	* the DisplayList is still holding a native reference to the memory.		* the DisplayList is still holding a native reference to the memory.
			*
			* @hide
	*/		*/
	class DisplayListCanvas extends HardwareCanvas {		public class DisplayListCanvas extends Canvas {
	// The recording canvas pool should be large enough to handle a deeply nested		// The recording canvas pool should be large enough to handle a deeply nested
	// view hierarchy because display lists are generated recursively.		// view hierarchy because display lists are generated recursively.
	private static final int POOL_LIMIT = 25;		private static final int POOL_LIMIT = 25;
	@@ -85,7 +88,6 @@ class DisplayListCanvas extends HardwareCanvas {
	// Constructors		// Constructors
	///////////////////////////////////////////////////////////////////////////		///////////////////////////////////////////////////////////////////////////


	private DisplayListCanvas() {		private DisplayListCanvas() {
	super(nCreateDisplayListRenderer());		super(nCreateDisplayListRenderer());
	}		}
	@@ -102,6 +104,16 @@ class DisplayListCanvas extends HardwareCanvas {
	// Canvas management		// Canvas management
	///////////////////////////////////////////////////////////////////////////		///////////////////////////////////////////////////////////////////////////

			@Override
			public boolean isHardwareAccelerated() {
			return true;
			}

			@Override
			public void setBitmap(Bitmap bitmap) {
			throw new UnsupportedOperationException();
			}

	@Override		@Override
	public boolean isOpaque() {		public boolean isOpaque() {
	return false;		return false;
	@@ -171,7 +183,11 @@ class DisplayListCanvas extends HardwareCanvas {

	private static native void nInsertReorderBarrier(long renderer, boolean enableReorder);		private static native void nInsertReorderBarrier(long renderer, boolean enableReorder);

	@Override		/**
			* Invoked before any drawing operation is performed in this canvas.
			*
			* @param dirty The dirty rectangle to update, can be null.
			*/
	public void onPreDraw(Rect dirty) {		public void onPreDraw(Rect dirty) {
	if (dirty != null) {		if (dirty != null) {
	nPrepareDirty(mNativeCanvasWrapper, dirty.left, dirty.top, dirty.right, dirty.bottom);		nPrepareDirty(mNativeCanvasWrapper, dirty.left, dirty.top, dirty.right, dirty.bottom);
	@@ -183,7 +199,9 @@ class DisplayListCanvas extends HardwareCanvas {
	private static native void nPrepare(long renderer);		private static native void nPrepare(long renderer);
	private static native void nPrepareDirty(long renderer, int left, int top, int right, int bottom);		private static native void nPrepareDirty(long renderer, int left, int top, int right, int bottom);

	@Override		/**
			* Invoked after all drawing operation have been performed.
			*/
	public void onPostDraw() {		public void onPostDraw() {
	nFinish(mNativeCanvasWrapper);		nFinish(mNativeCanvasWrapper);
	}		}
	@@ -194,7 +212,13 @@ class DisplayListCanvas extends HardwareCanvas {
	// Functor		// Functor
	///////////////////////////////////////////////////////////////////////////		///////////////////////////////////////////////////////////////////////////

	@Override		/**
			* Calls the function specified with the drawGLFunction function pointer. This is
			* functionality used by webkit for calling into their renderer from our display lists.
			* This function may return true if an invalidation is needed after the call.
			*
			* @param drawGLFunction A native function pointer
			*/
	public void callDrawGLFunction2(long drawGLFunction) {		public void callDrawGLFunction2(long drawGLFunction) {
	nCallDrawGLFunction(mNativeCanvasWrapper, drawGLFunction);		nCallDrawGLFunction(mNativeCanvasWrapper, drawGLFunction);
	}		}
	@@ -207,7 +231,23 @@ class DisplayListCanvas extends HardwareCanvas {

	protected static native long nFinishRecording(long renderer);		protected static native long nFinishRecording(long renderer);

	@Override		/**
			* Draws the specified display list onto this canvas. The display list can only
			* be drawn if {@link android.view.RenderNode#isValid()} returns true.
			*
			* @param renderNode The RenderNode to replay.
			*/
			public void drawRenderNode(RenderNode renderNode) {
			drawRenderNode(renderNode, RenderNode.FLAG_CLIP_CHILDREN);
			}

			/**
			* Draws the specified display list onto this canvas.
			*
			* @param renderNode The RenderNode to replay.
			* @param flags Optional flags about drawing, see {@link RenderNode} for
			* the possible flags.
			*/
	public void drawRenderNode(RenderNode renderNode, int flags) {		public void drawRenderNode(RenderNode renderNode, int flags) {
	nDrawRenderNode(mNativeCanvasWrapper, renderNode.getNativeDisplayList(), flags);		nDrawRenderNode(mNativeCanvasWrapper, renderNode.getNativeDisplayList(), flags);
	}		}
	@@ -219,6 +259,14 @@ class DisplayListCanvas extends HardwareCanvas {
	// Hardware layer		// Hardware layer
	///////////////////////////////////////////////////////////////////////////		///////////////////////////////////////////////////////////////////////////

			/**
			* Draws the specified layer onto this canvas.
			*
			* @param layer The layer to composite on this canvas
			* @param x The left coordinate of the layer
			* @param y The top coordinate of the layer
			* @param paint The paint used to draw the layer
			*/
	void drawHardwareLayer(HardwareLayer layer, float x, float y, Paint paint) {		void drawHardwareLayer(HardwareLayer layer, float x, float y, Paint paint) {
	layer.setLayerPaint(paint);		layer.setLayerPaint(paint);
	nDrawLayer(mNativeCanvasWrapper, layer.getLayerHandle(), x, y);		nDrawLayer(mNativeCanvasWrapper, layer.getLayerHandle(), x, y);
	@@ -253,7 +301,6 @@ class DisplayListCanvas extends HardwareCanvas {
	private static native void nDrawPatch(long renderer, long bitmap, long chunk,		private static native void nDrawPatch(long renderer, long bitmap, long chunk,
	float left, float top, float right, float bottom, long paint);		float left, float top, float right, float bottom, long paint);

	@Override
	public void drawCircle(CanvasProperty<Float> cx, CanvasProperty<Float> cy,		public void drawCircle(CanvasProperty<Float> cx, CanvasProperty<Float> cy,
	CanvasProperty<Float> radius, CanvasProperty<Paint> paint) {		CanvasProperty<Float> radius, CanvasProperty<Paint> paint) {
	nDrawCircle(mNativeCanvasWrapper, cx.getNativeContainer(), cy.getNativeContainer(),		nDrawCircle(mNativeCanvasWrapper, cx.getNativeContainer(), cy.getNativeContainer(),
	@@ -263,7 +310,6 @@ class DisplayListCanvas extends HardwareCanvas {
	private static native void nDrawCircle(long renderer, long propCx,		private static native void nDrawCircle(long renderer, long propCx,
	long propCy, long propRadius, long propPaint);		long propCy, long propRadius, long propPaint);

	@Override
	public void drawRoundRect(CanvasProperty<Float> left, CanvasProperty<Float> top,		public void drawRoundRect(CanvasProperty<Float> left, CanvasProperty<Float> top,
	CanvasProperty<Float> right, CanvasProperty<Float> bottom, CanvasProperty<Float> rx,		CanvasProperty<Float> right, CanvasProperty<Float> bottom, CanvasProperty<Float> rx,
	CanvasProperty<Float> ry, CanvasProperty<Paint> paint) {		CanvasProperty<Float> ry, CanvasProperty<Paint> paint) {

core/java/android/view/GhostView.java

+5 −5

Original line number	Original line	Diff line number	Diff line
	@@ -46,14 +46,14 @@ public class GhostView extends View {

	@Override		@Override
	protected void onDraw(Canvas canvas) {		protected void onDraw(Canvas canvas) {
	if (canvas instanceof HardwareCanvas) {		if (canvas instanceof DisplayListCanvas) {
	HardwareCanvas hwCanvas = (HardwareCanvas) canvas;		DisplayListCanvas dlCanvas = (DisplayListCanvas) canvas;
	mView.mRecreateDisplayList = true;		mView.mRecreateDisplayList = true;
	RenderNode renderNode = mView.getDisplayList();		RenderNode renderNode = mView.getDisplayList();
	if (renderNode.isValid()) {		if (renderNode.isValid()) {
	hwCanvas.insertReorderBarrier(); // enable shadow for this rendernode		dlCanvas.insertReorderBarrier(); // enable shadow for this rendernode
	hwCanvas.drawRenderNode(renderNode);		dlCanvas.drawRenderNode(renderNode);
	hwCanvas.insertInorderBarrier(); // re-disable reordering/shadows		dlCanvas.insertInorderBarrier(); // re-disable reordering/shadows
	}		}
	}		}
	}		}

core/java/android/view/HardwareCanvas.java

deleted100644 → 0

+0 −124

Original line number	Original line	Diff line number	Diff line
	/*
	* Copyright (C) 2010 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 android.view;

	import android.graphics.Bitmap;
	import android.graphics.Canvas;
	import android.graphics.CanvasProperty;
	import android.graphics.Paint;
	import android.graphics.Rect;

	/**
	* Hardware accelerated canvas.
	*
	* @hide
	*/
	public abstract class HardwareCanvas extends Canvas {

	/**
	* Pass a reference to the native renderer to our superclass's
	* constructor.
	*/
	protected HardwareCanvas(long renderer) {
	super(renderer);
	}

	@Override
	public boolean isHardwareAccelerated() {
	return true;
	}

	@Override
	public void setBitmap(Bitmap bitmap) {
	throw new UnsupportedOperationException();
	}

	/**
	* Invoked before any drawing operation is performed in this canvas.
	*
	* @param dirty The dirty rectangle to update, can be null.
	*
	* @hide
	*/
	public abstract void onPreDraw(Rect dirty);

	/**
	* Invoked after all drawing operation have been performed.
	*
	* @hide
	*/
	public abstract void onPostDraw();

	/**
	* Draws the specified display list onto this canvas. The display list can only
	* be drawn if {@link android.view.RenderNode#isValid()} returns true.
	*
	* @param renderNode The RenderNode to replay.
	*/
	public void drawRenderNode(RenderNode renderNode) {
	drawRenderNode(renderNode, RenderNode.FLAG_CLIP_CHILDREN);
	}

	/**
	* Draws the specified display list onto this canvas.
	*
	* @param renderNode The RenderNode to replay.
	* @param dirty Ignored, can be null.
	* @param flags Optional flags about drawing, see {@link RenderNode} for
	* the possible flags.
	*
	* @hide
	*/
	public abstract void drawRenderNode(RenderNode renderNode, int flags);

	/**
	* Draws the specified layer onto this canvas.
	*
	* @param layer The layer to composite on this canvas
	* @param x The left coordinate of the layer
	* @param y The top coordinate of the layer
	* @param paint The paint used to draw the layer
	*
	* @hide
	*/
	abstract void drawHardwareLayer(HardwareLayer layer, float x, float y, Paint paint);

	/**
	* Calls the function specified with the drawGLFunction function pointer. This is
	* functionality used by webkit for calling into their renderer from our display lists.
	* This function may return true if an invalidation is needed after the call.
	*
	* @param drawGLFunction A native function pointer
	*
	* @hide
	*/
	public void callDrawGLFunction2(long drawGLFunction) {
	// Noop - this is done in the display list recorder subclass
	}

	public abstract void drawCircle(CanvasProperty<Float> cx, CanvasProperty<Float> cy,
	CanvasProperty<Float> radius, CanvasProperty<Paint> paint);

	public abstract void drawRoundRect(CanvasProperty<Float> left, CanvasProperty<Float> top,
	CanvasProperty<Float> right, CanvasProperty<Float> bottom,
	CanvasProperty<Float> rx, CanvasProperty<Float> ry,
	CanvasProperty<Paint> paint);

	public static void setProperty(String name, String value) {
	DisplayListCanvas.setProperty(name, value);
	}
	}

core/java/android/view/HardwareRenderer.java

+2 −2

Original line number	Original line	Diff line number	Diff line
	@@ -326,7 +326,7 @@ public abstract class HardwareRenderer {
	*		*
	* @param canvas The Canvas used to render the view.		* @param canvas The Canvas used to render the view.
	*/		*/
	void onHardwarePreDraw(HardwareCanvas canvas);		void onHardwarePreDraw(DisplayListCanvas canvas);

	/**		/**
	* Invoked after a view is drawn by a hardware renderer.		* Invoked after a view is drawn by a hardware renderer.
	@@ -334,7 +334,7 @@ public abstract class HardwareRenderer {
	*		*
	* @param canvas The Canvas used to render the view.		* @param canvas The Canvas used to render the view.
	*/		*/
	void onHardwarePostDraw(HardwareCanvas canvas);		void onHardwarePostDraw(DisplayListCanvas canvas);
	}		}

	/**		/**

core/java/android/view/RenderNode.java

+19 −19

Original line number	Original line	Diff line number	Diff line
	@@ -26,7 +26,7 @@ import android.graphics.Rect;
	/**		/**
	* <p>A display list records a series of graphics related operations and can replay		* <p>A display list records a series of graphics related operations and can replay
	* them later. Display lists are usually built by recording operations on a		* them later. Display lists are usually built by recording operations on a
	* {@link HardwareCanvas}. Replaying the operations from a display list avoids		* {@link DisplayListCanvas}. Replaying the operations from a display list avoids
	* executing application code on every frame, and is thus much more efficient.</p>		* executing application code on every frame, and is thus much more efficient.</p>
	*		*
	* <p>Display lists are used internally for all views by default, and are not		* <p>Display lists are used internally for all views by default, and are not
	@@ -43,7 +43,7 @@ import android.graphics.Rect;
	* affected paragraph needs to be recorded again.</p>		* affected paragraph needs to be recorded again.</p>
	*		*
	* <h3>Hardware acceleration</h3>		* <h3>Hardware acceleration</h3>
	* <p>Display lists can only be replayed using a {@link HardwareCanvas}. They are not		* <p>Display lists can only be replayed using a {@link DisplayListCanvas}. They are not
	* supported in software. Always make sure that the {@link android.graphics.Canvas}		* supported in software. Always make sure that the {@link android.graphics.Canvas}
	* you are using to render a display list is hardware accelerated using		* you are using to render a display list is hardware accelerated using
	* {@link android.graphics.Canvas#isHardwareAccelerated()}.</p>		* {@link android.graphics.Canvas#isHardwareAccelerated()}.</p>
	@@ -53,7 +53,7 @@ import android.graphics.Rect;
	* HardwareRenderer renderer = myView.getHardwareRenderer();		* HardwareRenderer renderer = myView.getHardwareRenderer();
	* if (renderer != null) {		* if (renderer != null) {
	* DisplayList displayList = renderer.createDisplayList();		* DisplayList displayList = renderer.createDisplayList();
	* HardwareCanvas canvas = displayList.start(width, height);		* DisplayListCanvas canvas = displayList.start(width, height);
	* try {		* try {
	* // Draw onto the canvas		* // Draw onto the canvas
	* // For instance: canvas.drawBitmap(...);		* // For instance: canvas.drawBitmap(...);
	@@ -67,8 +67,8 @@ import android.graphics.Rect;
	* <pre class="prettyprint">		* <pre class="prettyprint">
	* protected void onDraw(Canvas canvas) {		* protected void onDraw(Canvas canvas) {
	* if (canvas.isHardwareAccelerated()) {		* if (canvas.isHardwareAccelerated()) {
	* HardwareCanvas hardwareCanvas = (HardwareCanvas) canvas;		* DisplayListCanvas displayListCanvas = (DisplayListCanvas) canvas;
	* hardwareCanvas.drawDisplayList(mDisplayList);		* displayListCanvas.drawDisplayList(mDisplayList);
	* }		* }
	* }		* }
	* </pre>		* </pre>
	@@ -92,7 +92,7 @@ import android.graphics.Rect;
	* <pre class="prettyprint">		* <pre class="prettyprint">
	* private void createDisplayList() {		* private void createDisplayList() {
	* mDisplayList = DisplayList.create("MyDisplayList");		* mDisplayList = DisplayList.create("MyDisplayList");
	* HardwareCanvas canvas = mDisplayList.start(width, height);		* DisplayListCanvas canvas = mDisplayList.start(width, height);
	* try {		* try {
	* for (Bitmap b : mBitmaps) {		* for (Bitmap b : mBitmaps) {
	* canvas.drawBitmap(b, 0.0f, 0.0f, null);		* canvas.drawBitmap(b, 0.0f, 0.0f, null);
	@@ -105,8 +105,8 @@ import android.graphics.Rect;
	*		*
	* protected void onDraw(Canvas canvas) {		* protected void onDraw(Canvas canvas) {
	* if (canvas.isHardwareAccelerated()) {		* if (canvas.isHardwareAccelerated()) {
	* HardwareCanvas hardwareCanvas = (HardwareCanvas) canvas;		* DisplayListCanvas displayListCanvas = (DisplayListCanvas) canvas;
	* hardwareCanvas.drawDisplayList(mDisplayList);		* displayListCanvas.drawDisplayList(mDisplayList);
	* }		* }
	* }		* }
	*		*
	@@ -128,7 +128,7 @@ import android.graphics.Rect;
	public class RenderNode {		public class RenderNode {
	/**		/**
	* Flag used when calling		* Flag used when calling
	* {@link HardwareCanvas#drawRenderNode(RenderNode, android.graphics.Rect, int)}		* {@link DisplayListCanvas#drawRenderNode
	* When this flag is set, draw operations lying outside of the bounds of the		* When this flag is set, draw operations lying outside of the bounds of the
	* display list will be culled early. It is recommeneded to always set this		* display list will be culled early. It is recommeneded to always set this
	* flag.		* flag.
	@@ -140,29 +140,29 @@ public class RenderNode {
	/**		/**
	* Indicates that the display list is done drawing.		* Indicates that the display list is done drawing.
	*		*
	* @see HardwareCanvas#drawRenderNode(RenderNode, android.graphics.Rect, int)		* @see DisplayListCanvas#drawRenderNode(RenderNode, int)
	*/		*/
	public static final int STATUS_DONE = 0x0;		public static final int STATUS_DONE = 0x0;

	/**		/**
	* Indicates that the display list needs another drawing pass.		* Indicates that the display list needs another drawing pass.
	*		*
	* @see HardwareCanvas#drawRenderNode(RenderNode, android.graphics.Rect, int)		* @see DisplayListCanvas#drawRenderNode(RenderNode, int)
	*/		*/
	public static final int STATUS_DRAW = 0x1;		public static final int STATUS_DRAW = 0x1;

	/**		/**
	* Indicates that the display list needs to re-execute its GL functors.		* Indicates that the display list needs to re-execute its GL functors.
	*		*
	* @see HardwareCanvas#drawRenderNode(RenderNode, android.graphics.Rect, int)		* @see DisplayListCanvas#drawRenderNode(RenderNode, int)
	* @see HardwareCanvas#callDrawGLFunction(long)		* @see DisplayListCanvas#callDrawGLFunction2(long)
	*/		*/
	public static final int STATUS_INVOKE = 0x2;		public static final int STATUS_INVOKE = 0x2;

	/**		/**
	* Indicates that the display list performed GL drawing operations.		* Indicates that the display list performed GL drawing operations.
	*		*
	* @see HardwareCanvas#drawRenderNode(RenderNode, android.graphics.Rect, int)		* @see DisplayListCanvas#drawRenderNode(RenderNode, int)
	*/		*/
	public static final int STATUS_DREW = 0x4;		public static final int STATUS_DREW = 0x4;

	@@ -213,7 +213,7 @@ public class RenderNode {
	* stored in this display list.		* stored in this display list.
	*		*
	* Calling this method will mark the render node invalid until		* Calling this method will mark the render node invalid until
	* {@link #end(HardwareCanvas)} is called.		* {@link #end(DisplayListCanvas)} is called.
	* Only valid render nodes can be replayed.		* Only valid render nodes can be replayed.
	*		*
	* @param width The width of the recording viewport		* @param width The width of the recording viewport
	@@ -221,11 +221,11 @@ public class RenderNode {
	*		*
	* @return A canvas to record drawing operations.		* @return A canvas to record drawing operations.
	*		*
	* @see #end(HardwareCanvas)		* @see #end(DisplayListCanvas)
	* @see #isValid()		* @see #isValid()
	*/		*/
	public HardwareCanvas start(int width, int height) {		public DisplayListCanvas start(int width, int height) {
	HardwareCanvas canvas = DisplayListCanvas.obtain(this);		DisplayListCanvas canvas = DisplayListCanvas.obtain(this);
	canvas.setViewport(width, height);		canvas.setViewport(width, height);
	// The dirty rect should always be null for a display list		// The dirty rect should always be null for a display list
	canvas.onPreDraw(null);		canvas.onPreDraw(null);
	@@ -240,7 +240,7 @@ public class RenderNode {
	* @see #start(int, int)		* @see #start(int, int)
	* @see #isValid()		* @see #isValid()
	*/		*/
	public void end(HardwareCanvas endCanvas) {		public void end(DisplayListCanvas endCanvas) {
	if (!(endCanvas instanceof DisplayListCanvas)) {		if (!(endCanvas instanceof DisplayListCanvas)) {
	throw new IllegalArgumentException("Passed an invalid canvas to end!");		throw new IllegalArgumentException("Passed an invalid canvas to end!");
	}		}