Merge "Remove GLRenderer" (7e3a7fc3) · Commits · e / os / android_frameworks_base

core/java/android/view/GLES20Canvas.java

+4 −110

Original line number	Diff line number	Diff line
		@@ -75,22 +75,10 @@ class GLES20Canvas extends HardwareCanvas {
		// Constructors
		///////////////////////////////////////////////////////////////////////////

		/**
		* Creates a canvas to render directly on screen.
		*/
		GLES20Canvas(boolean translucent) {
		this(false, translucent);
		}

		protected GLES20Canvas(boolean record, boolean translucent) {
		mOpaque = !translucent;

		if (record) {
		// TODO: Merge with GLES20RecordingCanvas
		protected GLES20Canvas() {
		mOpaque = false;
		mRenderer = nCreateDisplayListRenderer();
		} else {
		mRenderer = nCreateRenderer();
		}

		setupFinalizer();
		}

		@@ -102,7 +90,6 @@ class GLES20Canvas extends HardwareCanvas {
		}
		}

		private static native long nCreateRenderer();
		private static native long nCreateDisplayListRenderer();
		private static native void nResetDisplayListRenderer(long renderer);
		private static native void nDestroyRenderer(long renderer);
		@@ -130,36 +117,6 @@ class GLES20Canvas extends HardwareCanvas {

		private static native void nSetProperty(String name, String value);

		///////////////////////////////////////////////////////////////////////////
		// Hardware layers
		///////////////////////////////////////////////////////////////////////////

		@Override
		void pushLayerUpdate(HardwareLayer layer) {
		nPushLayerUpdate(mRenderer, layer.getLayer());
		}

		@Override
		void cancelLayerUpdate(HardwareLayer layer) {
		nCancelLayerUpdate(mRenderer, layer.getLayer());
		}

		@Override
		void flushLayerUpdates() {
		nFlushLayerUpdates(mRenderer);
		}

		@Override
		void clearLayerUpdates() {
		nClearLayerUpdates(mRenderer);
		}

		static native boolean nCopyLayer(long layerId, long bitmap);
		private static native void nClearLayerUpdates(long renderer);
		private static native void nFlushLayerUpdates(long renderer);
		private static native void nPushLayerUpdate(long renderer, long layer);
		private static native void nCancelLayerUpdate(long renderer, long layer);

		///////////////////////////////////////////////////////////////////////////
		// Canvas management
		///////////////////////////////////////////////////////////////////////////
		@@ -234,20 +191,6 @@ class GLES20Canvas extends HardwareCanvas {

		private static native void nFinish(long renderer);

		/**
		* Returns the size of the stencil buffer required by the underlying
		* implementation.
		*
		* @return The minimum number of bits the stencil buffer must. Always >= 0.
		*
		* @hide
		*/
		public static int getStencilSize() {
		return nGetStencilSize();
		}

		private static native int nGetStencilSize();

		///////////////////////////////////////////////////////////////////////////
		// Functor
		///////////////////////////////////////////////////////////////////////////
		@@ -284,49 +227,6 @@ class GLES20Canvas extends HardwareCanvas {
		*/
		static final int FLUSH_CACHES_FULL = 2;

		/**
		* Flush caches to reclaim as much memory as possible. The amount of memory
		* to reclaim is indicate by the level parameter.
		*
		* The level can be one of {@link #FLUSH_CACHES_MODERATE} or
		* {@link #FLUSH_CACHES_FULL}.
		*
		* @param level Hint about the amount of memory to reclaim
		*/
		static void flushCaches(int level) {
		nFlushCaches(level);
		}

		private static native void nFlushCaches(int level);

		/**
		* Release all resources associated with the underlying caches. This should
		* only be called after a full flushCaches().
		*
		* @hide
		*/
		static void terminateCaches() {
		nTerminateCaches();
		}

		private static native void nTerminateCaches();

		static boolean initCaches() {
		return nInitCaches();
		}

		private static native boolean nInitCaches();

		///////////////////////////////////////////////////////////////////////////
		// Atlas
		///////////////////////////////////////////////////////////////////////////

		static void initAtlas(GraphicBuffer buffer, long[] map) {
		nInitAtlas(buffer, map, map.length);
		}

		private static native void nInitAtlas(GraphicBuffer buffer, long[] map, int count);

		///////////////////////////////////////////////////////////////////////////
		// Display list
		///////////////////////////////////////////////////////////////////////////
		@@ -899,12 +799,6 @@ class GLES20Canvas extends HardwareCanvas {
		private static native void nDrawPath(long renderer, long path, long paint);
		private static native void nDrawRects(long renderer, long region, long paint);

		void drawRects(float[] rects, int count, Paint paint) {
		nDrawRects(mRenderer, rects, count, paint.mNativePaint);
		}

		private static native void nDrawRects(long renderer, float[] rects, int count, long paint);

		@Override
		public void drawPicture(Picture picture) {
		if (picture.createdFromStream) {

core/java/android/view/GLES20RecordingCanvas.java

+1 −1

Original line number	Diff line number	Diff line
		@@ -36,7 +36,7 @@ class GLES20RecordingCanvas extends GLES20Canvas {
		RenderNode mNode;

		private GLES20RecordingCanvas() {
		super(true, true);
		super();
		}

		static GLES20RecordingCanvas obtain(@NonNull RenderNode node) {

core/java/android/view/GLRenderer.java

deleted100644 → 0

+0 −1521

File deleted.

Preview size limit exceeded, changes collapsed.

core/java/android/view/HardwareCanvas.java

+0 −42

Original line number	Diff line number	Diff line
		@@ -110,48 +110,6 @@ public abstract class HardwareCanvas extends Canvas {
		return RenderNode.STATUS_DONE;
		}

		/**
		* Indicates that the specified layer must be updated as soon as possible.
		*
		* @param layer The layer to update
		*
		* @see #clearLayerUpdates()
		*
		* @hide
		*/
		abstract void pushLayerUpdate(HardwareLayer layer);

		/**
		* Cancels a queued layer update. If the specified layer was not
		* queued for update, this method has no effect.
		*
		* @param layer The layer whose update to cancel
		*
		* @see #pushLayerUpdate(HardwareLayer)
		* @see #clearLayerUpdates()
		*
		* @hide
		*/
		abstract void cancelLayerUpdate(HardwareLayer layer);

		/**
		* Immediately executes all enqueued layer updates.
		*
		* @see #pushLayerUpdate(HardwareLayer)
		*
		* @hide
		*/
		abstract void flushLayerUpdates();

		/**
		* Removes all enqueued layer updates.
		*
		* @see #pushLayerUpdate(HardwareLayer)
		*
		* @hide
		*/
		abstract void clearLayerUpdates();

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

core/java/android/view/HardwareLayer.java

+0 −37

Original line number	Diff line number	Diff line
		@@ -172,24 +172,6 @@ final class HardwareLayer {
		});
		}

		/**
		* This exists to minimize impact into the current HardwareLayer paths as
		* some of the specifics of how to handle error cases in the fully
		* deferred model will work
		*/
		@Deprecated
		public void flushChanges() {
		if (HardwareRenderer.sUseRenderThread) {
		// Not supported, don't try.
		return;
		}

		boolean success = nFlushChanges(mFinalizer.get());
		if (!success) {
		destroy();
		}
		}

		public long getLayer() {
		return nGetLayer(mFinalizer.get());
		}
		@@ -216,33 +198,14 @@ final class HardwareLayer {
		return st;
		}

		/**
		* This should only be used by HardwareRenderer! Do not call directly
		*/
		static HardwareLayer createTextureLayer(HardwareRenderer renderer) {
		return new HardwareLayer(renderer, nCreateTextureLayer(), LAYER_TYPE_TEXTURE);
		}

		static HardwareLayer adoptTextureLayer(HardwareRenderer renderer, long layer) {
		return new HardwareLayer(renderer, layer, LAYER_TYPE_TEXTURE);
		}

		/**
		* This should only be used by HardwareRenderer! Do not call directly
		*/
		static HardwareLayer createDisplayListLayer(HardwareRenderer renderer,
		int width, int height) {
		return new HardwareLayer(renderer, nCreateRenderLayer(width, height), LAYER_TYPE_DISPLAY_LIST);
		}

		static HardwareLayer adoptDisplayListLayer(HardwareRenderer renderer, long layer) {
		return new HardwareLayer(renderer, layer, LAYER_TYPE_DISPLAY_LIST);
		}

		/** This also creates the underlying layer */
		private static native long nCreateTextureLayer();
		private static native long nCreateRenderLayer(int width, int height);

		private static native void nOnTextureDestroyed(long layerUpdater);

		private static native boolean nPrepare(long layerUpdater, int width, int height, boolean isOpaque);