Merge "Enable partial invalidates when rendering with OpenGL." into honeycomb (2ff6d705) · Commits · e / os / android_frameworks_base

core/java/android/view/GLES20Canvas.java

+82 −60

Original line number	Original line	Diff line number	Diff line
	@@ -192,21 +192,36 @@ class GLES20Canvas extends HardwareCanvas {
	nSetViewport(mRenderer, width, height);		nSetViewport(mRenderer, width, height);
	}		}

	private native void nSetViewport(int renderer, int width, int height);		private static native void nSetViewport(int renderer, int width, int height);

			/**
			* @hide
			*/
			public static boolean preserveBackBuffer() {
			return nPreserveBackBuffer();
			}

			private static native boolean nPreserveBackBuffer();

	@Override		@Override
	void onPreDraw() {		void onPreDraw(Rect dirty) {
			if (dirty != null) {
			nPrepareDirty(mRenderer, dirty.left, dirty.top, dirty.right, dirty.bottom, mOpaque);
			} else {
	nPrepare(mRenderer, mOpaque);		nPrepare(mRenderer, mOpaque);
	}		}
			}

	private native void nPrepare(int renderer, boolean opaque);		private static native void nPrepare(int renderer, boolean opaque);
			private static native void nPrepareDirty(int renderer, int left, int top, int right, int bottom,
			boolean opaque);

	@Override		@Override
	void onPostDraw() {		void onPostDraw() {
	nFinish(mRenderer);		nFinish(mRenderer);
	}		}

	private native void nFinish(int renderer);		private static native void nFinish(int renderer);

	@Override		@Override
	public boolean acquireContext() {		public boolean acquireContext() {
	@@ -217,14 +232,14 @@ class GLES20Canvas extends HardwareCanvas {
	return mContextLocked;		return mContextLocked;
	}		}

	private native void nAcquireContext(int renderer);		private static native void nAcquireContext(int renderer);

	@Override		@Override
	public boolean callDrawGLFunction(int drawGLFunction) {		public boolean callDrawGLFunction(int drawGLFunction) {
	return nCallDrawGLFunction(mRenderer, drawGLFunction);		return nCallDrawGLFunction(mRenderer, drawGLFunction);
	}		}

	private native boolean nCallDrawGLFunction(int renderer, int drawGLFunction);		private static native boolean nCallDrawGLFunction(int renderer, int drawGLFunction);

	@Override		@Override
	public void releaseContext() {		public void releaseContext() {
	@@ -234,7 +249,7 @@ class GLES20Canvas extends HardwareCanvas {
	}		}
	}		}

	private native void nReleaseContext(int renderer);		private static native void nReleaseContext(int renderer);

	///////////////////////////////////////////////////////////////////////////		///////////////////////////////////////////////////////////////////////////
	// Display list		// Display list
	@@ -244,7 +259,7 @@ class GLES20Canvas extends HardwareCanvas {
	return nGetDisplayList(mRenderer);		return nGetDisplayList(mRenderer);
	}		}

	private native int nGetDisplayList(int renderer);		private static native int nGetDisplayList(int renderer);

	static void destroyDisplayList(int displayList) {		static void destroyDisplayList(int displayList) {
	nDestroyDisplayList(displayList);		nDestroyDisplayList(displayList);
	@@ -257,7 +272,7 @@ class GLES20Canvas extends HardwareCanvas {
	return nDrawDisplayList(mRenderer, ((GLES20DisplayList) displayList).mNativeDisplayList);		return nDrawDisplayList(mRenderer, ((GLES20DisplayList) displayList).mNativeDisplayList);
	}		}

	private native boolean nDrawDisplayList(int renderer, int displayList);		private static native boolean nDrawDisplayList(int renderer, int displayList);

	///////////////////////////////////////////////////////////////////////////		///////////////////////////////////////////////////////////////////////////
	// Hardware layer		// Hardware layer
	@@ -271,7 +286,7 @@ class GLES20Canvas extends HardwareCanvas {
	if (hasColorFilter) nResetModifiers(mRenderer);		if (hasColorFilter) nResetModifiers(mRenderer);
	}		}

	private native void nDrawLayer(int renderer, int layer, float x, float y, int paint);		private static native void nDrawLayer(int renderer, int layer, float x, float y, int paint);

	void interrupt() {		void interrupt() {
	nInterrupt(mRenderer);		nInterrupt(mRenderer);
	@@ -281,8 +296,8 @@ class GLES20Canvas extends HardwareCanvas {
	nResume(mRenderer);		nResume(mRenderer);
	}		}

	private native void nInterrupt(int renderer);		private static native void nInterrupt(int renderer);
	private native void nResume(int renderer);		private static native void nResume(int renderer);

	///////////////////////////////////////////////////////////////////////////		///////////////////////////////////////////////////////////////////////////
	// Clipping		// Clipping
	@@ -303,7 +318,7 @@ class GLES20Canvas extends HardwareCanvas {
	return nClipRect(mRenderer, left, top, right, bottom, Region.Op.INTERSECT.nativeInt);		return nClipRect(mRenderer, left, top, right, bottom, Region.Op.INTERSECT.nativeInt);
	}		}

	private native boolean nClipRect(int renderer, float left, float top,		private static native boolean nClipRect(int renderer, float left, float top,
	float right, float bottom, int op);		float right, float bottom, int op);

	@Override		@Override
	@@ -316,7 +331,8 @@ class GLES20Canvas extends HardwareCanvas {
	return nClipRect(mRenderer, left, top, right, bottom, Region.Op.INTERSECT.nativeInt);		return nClipRect(mRenderer, left, top, right, bottom, Region.Op.INTERSECT.nativeInt);
	}		}

	private native boolean nClipRect(int renderer, int left, int top, int right, int bottom, int op);		private static native boolean nClipRect(int renderer, int left, int top, int right, int bottom,
			int op);

	@Override		@Override
	public boolean clipRect(Rect rect) {		public boolean clipRect(Rect rect) {
	@@ -355,14 +371,14 @@ class GLES20Canvas extends HardwareCanvas {
	return nGetClipBounds(mRenderer, bounds);		return nGetClipBounds(mRenderer, bounds);
	}		}

	private native boolean nGetClipBounds(int renderer, Rect bounds);		private static native boolean nGetClipBounds(int renderer, Rect bounds);

	@Override		@Override
	public boolean quickReject(float left, float top, float right, float bottom, EdgeType type) {		public boolean quickReject(float left, float top, float right, float bottom, EdgeType type) {
	return nQuickReject(mRenderer, left, top, right, bottom, type.nativeInt);		return nQuickReject(mRenderer, left, top, right, bottom, type.nativeInt);
	}		}

	private native boolean nQuickReject(int renderer, float left, float top,		private static native boolean nQuickReject(int renderer, float left, float top,
	float right, float bottom, int edge);		float right, float bottom, int edge);

	@Override		@Override
	@@ -384,56 +400,56 @@ class GLES20Canvas extends HardwareCanvas {
	if (dx != 0.0f \|\| dy != 0.0f) nTranslate(mRenderer, dx, dy);		if (dx != 0.0f \|\| dy != 0.0f) nTranslate(mRenderer, dx, dy);
	}		}

	private native void nTranslate(int renderer, float dx, float dy);		private static native void nTranslate(int renderer, float dx, float dy);

	@Override		@Override
	public void skew(float sx, float sy) {		public void skew(float sx, float sy) {
	nSkew(mRenderer, sx, sy);		nSkew(mRenderer, sx, sy);
	}		}

	private native void nSkew(int renderer, float sx, float sy);		private static native void nSkew(int renderer, float sx, float sy);

	@Override		@Override
	public void rotate(float degrees) {		public void rotate(float degrees) {
	nRotate(mRenderer, degrees);		nRotate(mRenderer, degrees);
	}		}

	private native void nRotate(int renderer, float degrees);		private static native void nRotate(int renderer, float degrees);

	@Override		@Override
	public void scale(float sx, float sy) {		public void scale(float sx, float sy) {
	nScale(mRenderer, sx, sy);		nScale(mRenderer, sx, sy);
	}		}

	private native void nScale(int renderer, float sx, float sy);		private static native void nScale(int renderer, float sx, float sy);

	@Override		@Override
	public void setMatrix(Matrix matrix) {		public void setMatrix(Matrix matrix) {
	nSetMatrix(mRenderer, matrix.native_instance);		nSetMatrix(mRenderer, matrix.native_instance);
	}		}

	private native void nSetMatrix(int renderer, int matrix);		private static native void nSetMatrix(int renderer, int matrix);

	@Override		@Override
	public int getNativeMatrix() {		public int getNativeMatrix() {
	return nGetMatrix(mRenderer);		return nGetMatrix(mRenderer);
	}		}

	private native int nGetMatrix(int renderer);		private static native int nGetMatrix(int renderer);

	@Override		@Override
	public void getMatrix(Matrix matrix) {		public void getMatrix(Matrix matrix) {
	nGetMatrix(mRenderer, matrix.native_instance);		nGetMatrix(mRenderer, matrix.native_instance);
	}		}

	private native void nGetMatrix(int renderer, int matrix);		private static native void nGetMatrix(int renderer, int matrix);

	@Override		@Override
	public void concat(Matrix matrix) {		public void concat(Matrix matrix) {
	nConcatMatrix(mRenderer, matrix.native_instance);		nConcatMatrix(mRenderer, matrix.native_instance);
	}		}

	private native void nConcatMatrix(int renderer, int matrix);		private static native void nConcatMatrix(int renderer, int matrix);

	///////////////////////////////////////////////////////////////////////////		///////////////////////////////////////////////////////////////////////////
	// State management		// State management
	@@ -449,7 +465,7 @@ class GLES20Canvas extends HardwareCanvas {
	return nSave(mRenderer, saveFlags);		return nSave(mRenderer, saveFlags);
	}		}

	private native int nSave(int renderer, int flags);		private static native int nSave(int renderer, int flags);

	@Override		@Override
	public int saveLayer(RectF bounds, Paint paint, int saveFlags) {		public int saveLayer(RectF bounds, Paint paint, int saveFlags) {
	@@ -469,8 +485,8 @@ class GLES20Canvas extends HardwareCanvas {
	return save(saveFlags);		return save(saveFlags);
	}		}

	private native int nSaveLayer(int renderer, float left, float top, float right, float bottom,		private static native int nSaveLayer(int renderer, float left, float top,
	int paint, int saveFlags);		float right, float bottom, int paint, int saveFlags);

	@Override		@Override
	public int saveLayerAlpha(RectF bounds, int alpha, int saveFlags) {		public int saveLayerAlpha(RectF bounds, int alpha, int saveFlags) {
	@@ -487,7 +503,7 @@ class GLES20Canvas extends HardwareCanvas {
	return save(saveFlags);		return save(saveFlags);
	}		}

	private native int nSaveLayerAlpha(int renderer, float left, float top, float right,		private static native int nSaveLayerAlpha(int renderer, float left, float top, float right,
	float bottom, int alpha, int saveFlags);		float bottom, int alpha, int saveFlags);

	@Override		@Override
	@@ -495,21 +511,21 @@ class GLES20Canvas extends HardwareCanvas {
	nRestore(mRenderer);		nRestore(mRenderer);
	}		}

	private native void nRestore(int renderer);		private static native void nRestore(int renderer);

	@Override		@Override
	public void restoreToCount(int saveCount) {		public void restoreToCount(int saveCount) {
	nRestoreToCount(mRenderer, saveCount);		nRestoreToCount(mRenderer, saveCount);
	}		}

	private native void nRestoreToCount(int renderer, int saveCount);		private static native void nRestoreToCount(int renderer, int saveCount);

	@Override		@Override
	public int getSaveCount() {		public int getSaveCount() {
	return nGetSaveCount(mRenderer);		return nGetSaveCount(mRenderer);
	}		}

	private native int nGetSaveCount(int renderer);		private static native int nGetSaveCount(int renderer);

	///////////////////////////////////////////////////////////////////////////		///////////////////////////////////////////////////////////////////////////
	// Filtering		// Filtering
	@@ -538,8 +554,9 @@ class GLES20Canvas extends HardwareCanvas {
	if (hasModifier) nResetModifiers(mRenderer);		if (hasModifier) nResetModifiers(mRenderer);
	}		}

	private native void nDrawArc(int renderer, float left, float top, float right, float bottom,		private static native void nDrawArc(int renderer, float left, float top,
	float startAngle, float sweepAngle, boolean useCenter, int paint);		float right, float bottom, float startAngle, float sweepAngle,
			boolean useCenter, int paint);

	@Override		@Override
	public void drawARGB(int a, int r, int g, int b) {		public void drawARGB(int a, int r, int g, int b) {
	@@ -556,7 +573,7 @@ class GLES20Canvas extends HardwareCanvas {
	if (hasColorFilter) nResetModifiers(mRenderer);		if (hasColorFilter) nResetModifiers(mRenderer);
	}		}

	private native void nDrawPatch(int renderer, int bitmap, byte[] buffer, byte[] chunks,		private static native void nDrawPatch(int renderer, int bitmap, byte[] buffer, byte[] chunks,
	float left, float top, float right, float bottom, int paint);		float left, float top, float right, float bottom, int paint);

	@Override		@Override
	@@ -568,7 +585,7 @@ class GLES20Canvas extends HardwareCanvas {
	if (hasColorFilter) nResetModifiers(mRenderer);		if (hasColorFilter) nResetModifiers(mRenderer);
	}		}

	private native void nDrawBitmap(		private static native void nDrawBitmap(
	int renderer, int bitmap, byte[] buffer, float left, float top, int paint);		int renderer, int bitmap, byte[] buffer, float left, float top, int paint);

	@Override		@Override
	@@ -581,7 +598,8 @@ class GLES20Canvas extends HardwareCanvas {
	if (hasColorFilter) nResetModifiers(mRenderer);		if (hasColorFilter) nResetModifiers(mRenderer);
	}		}

	private native void nDrawBitmap(int renderer, int bitmap, byte[] buff, int matrix, int paint);		private static native void nDrawBitmap(int renderer, int bitmap, byte[] buff,
			int matrix, int paint);

	@Override		@Override
	public void drawBitmap(Bitmap bitmap, Rect src, Rect dst, Paint paint) {		public void drawBitmap(Bitmap bitmap, Rect src, Rect dst, Paint paint) {
	@@ -616,7 +634,7 @@ class GLES20Canvas extends HardwareCanvas {
	if (hasColorFilter) nResetModifiers(mRenderer);		if (hasColorFilter) nResetModifiers(mRenderer);
	}		}

	private native void nDrawBitmap(int renderer, int bitmap, byte[] buffer,		private static native void nDrawBitmap(int renderer, int bitmap, byte[] buffer,
	float srcLeft, float srcTop, float srcRight, float srcBottom,		float srcLeft, float srcTop, float srcRight, float srcBottom,
	float left, float top, float right, float bottom, int paint);		float left, float top, float right, float bottom, int paint);

	@@ -665,7 +683,7 @@ class GLES20Canvas extends HardwareCanvas {
	if (hasColorFilter) nResetModifiers(mRenderer);		if (hasColorFilter) nResetModifiers(mRenderer);
	}		}

	private native void nDrawBitmapMesh(int renderer, int bitmap, byte[] buffer,		private static native void nDrawBitmapMesh(int renderer, int bitmap, byte[] buffer,
	int meshWidth, int meshHeight, float[] verts, int vertOffset,		int meshWidth, int meshHeight, float[] verts, int vertOffset,
	int[] colors, int colorOffset, int paint);		int[] colors, int colorOffset, int paint);

	@@ -676,7 +694,8 @@ class GLES20Canvas extends HardwareCanvas {
	if (hasModifier) nResetModifiers(mRenderer);		if (hasModifier) nResetModifiers(mRenderer);
	}		}

	private native void nDrawCircle(int renderer, float cx, float cy, float radius, int paint);		private static native void nDrawCircle(int renderer, float cx, float cy,
			float radius, int paint);

	@Override		@Override
	public void drawColor(int color) {		public void drawColor(int color) {
	@@ -688,7 +707,7 @@ class GLES20Canvas extends HardwareCanvas {
	nDrawColor(mRenderer, color, mode.nativeInt);		nDrawColor(mRenderer, color, mode.nativeInt);
	}		}

	private native void nDrawColor(int renderer, int color, int mode);		private static native void nDrawColor(int renderer, int color, int mode);

	@Override		@Override
	public void drawLine(float startX, float startY, float stopX, float stopY, Paint paint) {		public void drawLine(float startX, float startY, float stopX, float stopY, Paint paint) {
	@@ -709,7 +728,8 @@ class GLES20Canvas extends HardwareCanvas {
	if (hasModifier) nResetModifiers(mRenderer);		if (hasModifier) nResetModifiers(mRenderer);
	}		}

	private native void nDrawLines(int renderer, float[] points, int offset, int count, int paint);		private static native void nDrawLines(int renderer, float[] points,
			int offset, int count, int paint);

	@Override		@Override
	public void drawLines(float[] pts, Paint paint) {		public void drawLines(float[] pts, Paint paint) {
	@@ -723,8 +743,8 @@ class GLES20Canvas extends HardwareCanvas {
	if (hasModifier) nResetModifiers(mRenderer);		if (hasModifier) nResetModifiers(mRenderer);
	}		}

	private native void nDrawOval(int renderer, float left, float top, float right, float bottom,		private static native void nDrawOval(int renderer, float left, float top,
	int paint);		float right, float bottom, int paint);

	@Override		@Override
	public void drawPaint(Paint paint) {		public void drawPaint(Paint paint) {
	@@ -746,8 +766,8 @@ class GLES20Canvas extends HardwareCanvas {
	if (hasModifier) nResetModifiers(mRenderer);		if (hasModifier) nResetModifiers(mRenderer);
	}		}

	private native void nDrawPath(int renderer, int path, int paint);		private static native void nDrawPath(int renderer, int path, int paint);
	private native void nDrawRects(int renderer, int region, int paint);		private static native void nDrawRects(int renderer, int region, int paint);

	@Override		@Override
	public void drawPicture(Picture picture) {		public void drawPicture(Picture picture) {
	@@ -798,8 +818,8 @@ class GLES20Canvas extends HardwareCanvas {
	if (hasModifier) nResetModifiers(mRenderer);		if (hasModifier) nResetModifiers(mRenderer);
	}		}

	private native void nDrawRect(int renderer, float left, float top, float right, float bottom,		private static native void nDrawRect(int renderer, float left, float top,
	int paint);		float right, float bottom, int paint);

	@Override		@Override
	public void drawRect(Rect r, Paint paint) {		public void drawRect(Rect r, Paint paint) {
	@@ -824,7 +844,7 @@ class GLES20Canvas extends HardwareCanvas {
	if (hasModifier) nResetModifiers(mRenderer);		if (hasModifier) nResetModifiers(mRenderer);
	}		}

	private native void nDrawRoundRect(int renderer, float left, float top,		private static native void nDrawRoundRect(int renderer, float left, float top,
	float right, float bottom, float rx, float y, int paint);		float right, float bottom, float rx, float y, int paint);

	@Override		@Override
	@@ -841,8 +861,8 @@ class GLES20Canvas extends HardwareCanvas {
	}		}
	}		}

	private native void nDrawText(int renderer, char[] text, int index, int count, float x, float y,		private static native void nDrawText(int renderer, char[] text, int index, int count,
	int bidiFlags, int paint);		float x, float y, int bidiFlags, int paint);

	@Override		@Override
	public void drawText(CharSequence text, int start, int end, float x, float y, Paint paint) {		public void drawText(CharSequence text, int start, int end, float x, float y, Paint paint) {
	@@ -858,7 +878,8 @@ class GLES20Canvas extends HardwareCanvas {
	} else {		} else {
	char[] buf = TemporaryBuffer.obtain(end - start);		char[] buf = TemporaryBuffer.obtain(end - start);
	TextUtils.getChars(text, start, end, buf, 0);		TextUtils.getChars(text, start, end, buf, 0);
	nDrawText(mRenderer, buf, 0, end - start, x, y, paint.mBidiFlags, paint.mNativePaint);		nDrawText(mRenderer, buf, 0, end - start, x, y,
			paint.mBidiFlags, paint.mNativePaint);
	TemporaryBuffer.recycle(buf);		TemporaryBuffer.recycle(buf);
	}		}
	} finally {		} finally {
	@@ -880,8 +901,8 @@ class GLES20Canvas extends HardwareCanvas {
	}		}
	}		}

	private native void nDrawText(int renderer, String text, int start, int end, float x, float y,		private static native void nDrawText(int renderer, String text, int start, int end,
	int bidiFlags, int paint);		float x, float y, int bidiFlags, int paint);

	@Override		@Override
	public void drawText(String text, float x, float y, Paint paint) {		public void drawText(String text, float x, float y, Paint paint) {
	@@ -924,7 +945,7 @@ class GLES20Canvas extends HardwareCanvas {
	}		}
	}		}

	private native void nDrawTextRun(int renderer, char[] text, int index, int count,		private static native void nDrawTextRun(int renderer, char[] text, int index, int count,
	int contextIndex, int contextCount, float x, float y, int dir, int nativePaint);		int contextIndex, int contextCount, float x, float y, int dir, int nativePaint);

	@Override		@Override
	@@ -958,7 +979,7 @@ class GLES20Canvas extends HardwareCanvas {
	}		}
	}		}

	private native void nDrawTextRun(int renderer, String text, int start, int end,		private static native void nDrawTextRun(int renderer, String text, int start, int end,
	int contextStart, int contextEnd, float x, float y, int flags, int nativePaint);		int contextStart, int contextEnd, float x, float y, int flags, int nativePaint);

	@Override		@Override
	@@ -1001,9 +1022,10 @@ class GLES20Canvas extends HardwareCanvas {
	return false;		return false;
	}		}

	private native void nSetupShader(int renderer, int shader);		private static native void nSetupShader(int renderer, int shader);
	private native void nSetupColorFilter(int renderer, int colorFilter);		private static native void nSetupColorFilter(int renderer, int colorFilter);
	private native void nSetupShadow(int renderer, float radius, float dx, float dy, int color);		private static native void nSetupShadow(int renderer, float radius,
			float dx, float dy, int color);

	private native void nResetModifiers(int renderer);		private static native void nResetModifiers(int renderer);
	}		}

core/java/android/view/HardwareCanvas.java

+4 −1

Original line number	Original line	Diff line number	Diff line
	@@ -19,6 +19,7 @@ package android.view;
	import android.graphics.Bitmap;		import android.graphics.Bitmap;
	import android.graphics.Canvas;		import android.graphics.Canvas;
	import android.graphics.Paint;		import android.graphics.Paint;
			import android.graphics.Rect;

	/**		/**
	* Hardware accelerated canvas.		* Hardware accelerated canvas.
	@@ -38,8 +39,10 @@ public abstract class HardwareCanvas extends Canvas {

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

	/**		/**
	* Invoked after all drawing operation have been performed.		* Invoked after all drawing operation have been performed.

core/java/android/view/HardwareRenderer.java

+65 −10

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

	import android.graphics.Canvas;		import android.graphics.Canvas;
			import android.graphics.Paint;
			import android.graphics.Rect;
	import android.os.SystemClock;		import android.os.SystemClock;
	import android.util.EventLog;		import android.util.EventLog;
	import android.util.Log;		import android.util.Log;
	@@ -38,6 +40,16 @@ import javax.microedition.khronos.opengles.GL;
	public abstract class HardwareRenderer {		public abstract class HardwareRenderer {
	static final String LOG_TAG = "HardwareRenderer";		static final String LOG_TAG = "HardwareRenderer";

			/**
			* Turn on to only refresh the parts of the screen that need updating.
			*/
			public static final boolean RENDER_DIRTY_REGIONS = true;

			/**
			* Turn on to draw dirty regions every other frame.
			*/
			private static final boolean DEBUG_DIRTY_REGION = false;

	/**		/**
	* A process can set this flag to false to prevent the use of hardware		* A process can set this flag to false to prevent the use of hardware
	* rendering.		* rendering.
	@@ -111,8 +123,11 @@ public abstract class HardwareRenderer {
	*		*
	* @param view The view to draw.		* @param view The view to draw.
	* @param attachInfo AttachInfo tied to the specified view.		* @param attachInfo AttachInfo tied to the specified view.
			* @param callbacks Callbacks invoked when drawing happens.
			* @param dirty The dirty rectangle to update, can be null.
	*/		*/
	abstract void draw(View view, View.AttachInfo attachInfo, HardwareDrawCallbacks callbacks);		abstract void draw(View view, View.AttachInfo attachInfo, HardwareDrawCallbacks callbacks,
			Rect dirty);

	/**		/**
	* Creates a new display list that can be used to record batches of		* Creates a new display list that can be used to record batches of
	@@ -214,6 +229,8 @@ public abstract class HardwareRenderer {
	@SuppressWarnings({"deprecation"})		@SuppressWarnings({"deprecation"})
	static abstract class GlRenderer extends HardwareRenderer {		static abstract class GlRenderer extends HardwareRenderer {
	private static final int EGL_CONTEXT_CLIENT_VERSION = 0x3098;		private static final int EGL_CONTEXT_CLIENT_VERSION = 0x3098;
			private static final int EGL_SURFACE_TYPE = 0x3033;
			private static final int EGL_SWAP_BEHAVIOR_PRESERVED_BIT = 0x0400;

	static EGLContext sEglContext;		static EGLContext sEglContext;
	static EGL10 sEgl;		static EGL10 sEgl;
	@@ -226,6 +243,9 @@ public abstract class HardwareRenderer {

	GL mGl;		GL mGl;
	HardwareCanvas mCanvas;		HardwareCanvas mCanvas;
			int mFrameCount;
			Paint mDebugPaint;


	final int mGlVersion;		final int mGlVersion;
	final boolean mTranslucent;		final boolean mTranslucent;
	@@ -412,7 +432,7 @@ public abstract class HardwareRenderer {
	if (mEglSurface == null \|\| mEglSurface == EGL10.EGL_NO_SURFACE) {		if (mEglSurface == null \|\| mEglSurface == EGL10.EGL_NO_SURFACE) {
	int error = sEgl.eglGetError();		int error = sEgl.eglGetError();
	if (error == EGL10.EGL_BAD_NATIVE_WINDOW) {		if (error == EGL10.EGL_BAD_NATIVE_WINDOW) {
	Log.e("EglHelper", "createWindowSurface returned EGL_BAD_NATIVE_WINDOW.");		Log.e(LOG_TAG, "createWindowSurface returned EGL_BAD_NATIVE_WINDOW.");
	return null;		return null;
	}		}
	throw new RuntimeException("createWindowSurface failed "		throw new RuntimeException("createWindowSurface failed "
	@@ -428,6 +448,12 @@ public abstract class HardwareRenderer {
	+ getEGLErrorString(sEgl.eglGetError()));		+ getEGLErrorString(sEgl.eglGetError()));
	}		}

			if (RENDER_DIRTY_REGIONS) {
			if (!GLES20Canvas.preserveBackBuffer()) {
			Log.w(LOG_TAG, "Backbuffer cannot be preserved");
			}
			}

	return sEglContext.getGL();		return sEglContext.getGL();
	}		}

	@@ -476,7 +502,7 @@ public abstract class HardwareRenderer {
	return mGl != null && mCanvas != null;		return mGl != null && mCanvas != null;
	}		}

	void onPreDraw() {		void onPreDraw(Rect dirty) {
	}		}

	void onPostDraw() {		void onPostDraw() {
	@@ -492,8 +518,14 @@ public abstract class HardwareRenderer {
	}		}

	@Override		@Override
	void draw(View view, View.AttachInfo attachInfo, HardwareDrawCallbacks callbacks) {		void draw(View view, View.AttachInfo attachInfo, HardwareDrawCallbacks callbacks,
			Rect dirty) {
	if (canDraw()) {		if (canDraw()) {
			//noinspection PointlessBooleanExpression,ConstantConditions
			if (!HardwareRenderer.RENDER_DIRTY_REGIONS) {
			dirty = null;
			}

	attachInfo.mDrawingTime = SystemClock.uptimeMillis();		attachInfo.mDrawingTime = SystemClock.uptimeMillis();
	attachInfo.mIgnoreDirtyState = true;		attachInfo.mIgnoreDirtyState = true;
	view.mPrivateFlags \|= View.DRAWN;		view.mPrivateFlags \|= View.DRAWN;
	@@ -504,10 +536,11 @@ public abstract class HardwareRenderer {
	}		}

	if (checkCurrent()) {		if (checkCurrent()) {
	onPreDraw();		onPreDraw(dirty);

	HardwareCanvas canvas = mCanvas;		HardwareCanvas canvas = mCanvas;
	attachInfo.mHardwareCanvas = canvas;		attachInfo.mHardwareCanvas = canvas;

	int saveCount = canvas.save();		int saveCount = canvas.save();
	callbacks.onHardwarePreDraw(canvas);		callbacks.onHardwarePreDraw(canvas);

	@@ -515,6 +548,7 @@ public abstract class HardwareRenderer {
	view.mRecreateDisplayList =		view.mRecreateDisplayList =
	(view.mPrivateFlags & View.INVALIDATED) == View.INVALIDATED;		(view.mPrivateFlags & View.INVALIDATED) == View.INVALIDATED;
	view.mPrivateFlags &= ~View.INVALIDATED;		view.mPrivateFlags &= ~View.INVALIDATED;

	DisplayList displayList = view.getDisplayList();		DisplayList displayList = view.getDisplayList();
	if (displayList != null) {		if (displayList != null) {
	if (canvas.drawDisplayList(displayList)) {		if (canvas.drawDisplayList(displayList)) {
	@@ -524,6 +558,16 @@ public abstract class HardwareRenderer {
	// Shouldn't reach here		// Shouldn't reach here
	view.draw(canvas);		view.draw(canvas);
	}		}

			if (DEBUG_DIRTY_REGION) {
			if (mDebugPaint == null) {
			mDebugPaint = new Paint();
			mDebugPaint.setColor(0x7fff0000);
			}
			if (dirty != null && (mFrameCount++ & 1) == 0) {
			canvas.drawRect(dirty, mDebugPaint);
			}
			}
	} finally {		} finally {
	callbacks.onHardwarePostDraw(canvas);		callbacks.onHardwarePostDraw(canvas);
	canvas.restoreToCount(saveCount);		canvas.restoreToCount(saveCount);
	@@ -636,6 +680,8 @@ public abstract class HardwareRenderer {
	EGL10.EGL_ALPHA_SIZE, alphaSize,		EGL10.EGL_ALPHA_SIZE, alphaSize,
	EGL10.EGL_DEPTH_SIZE, depthSize,		EGL10.EGL_DEPTH_SIZE, depthSize,
	EGL10.EGL_STENCIL_SIZE, stencilSize,		EGL10.EGL_STENCIL_SIZE, stencilSize,
			EGL_SURFACE_TYPE, EGL10.EGL_WINDOW_BIT \|
			(RENDER_DIRTY_REGIONS ? EGL_SWAP_BEHAVIOR_PRESERVED_BIT : 0),
	EGL10.EGL_NONE });		EGL10.EGL_NONE });
	mValue = new int[1];		mValue = new int[1];
	mRedSize = redSize;		mRedSize = redSize;
	@@ -656,7 +702,16 @@ public abstract class HardwareRenderer {
	int g = findConfigAttrib(egl, display, config, EGL10.EGL_GREEN_SIZE, 0);		int g = findConfigAttrib(egl, display, config, EGL10.EGL_GREEN_SIZE, 0);
	int b = findConfigAttrib(egl, display, config, EGL10.EGL_BLUE_SIZE, 0);		int b = findConfigAttrib(egl, display, config, EGL10.EGL_BLUE_SIZE, 0);
	int a = findConfigAttrib(egl, display, config, EGL10.EGL_ALPHA_SIZE, 0);		int a = findConfigAttrib(egl, display, config, EGL10.EGL_ALPHA_SIZE, 0);
	if (r >= mRedSize && g >= mGreenSize && b >= mBlueSize && a >= mAlphaSize) {		boolean backBuffer;
			if (RENDER_DIRTY_REGIONS) {
			int surfaceType = findConfigAttrib(egl, display, config,
			EGL_SURFACE_TYPE, 0);
			backBuffer = (surfaceType & EGL_SWAP_BEHAVIOR_PRESERVED_BIT) != 0;
			} else {
			backBuffer = true;
			}
			if (r >= mRedSize && g >= mGreenSize && b >= mBlueSize && a >= mAlphaSize
			&& backBuffer) {
	return config;		return config;
	}		}
	}		}
	@@ -696,8 +751,8 @@ public abstract class HardwareRenderer {
	}		}

	@Override		@Override
	void onPreDraw() {		void onPreDraw(Rect dirty) {
	mGlCanvas.onPreDraw();		mGlCanvas.onPreDraw(dirty);
	}		}

	@Override		@Override

core/java/android/view/View.java

+29 −18

File changed.

Preview size limit exceeded, changes collapsed.

core/java/android/view/ViewGroup.java

+10 −0

Original line number	Original line	Diff line number	Diff line
	@@ -3529,10 +3529,20 @@ public abstract class ViewGroup extends View implements ViewParent, ViewManager
	(int) (boundingRect.bottom + 0.5f));		(int) (boundingRect.bottom + 0.5f));
	}		}

			if (child.mLayerType != LAYER_TYPE_NONE) {
			mPrivateFlags \|= INVALIDATED;
			mPrivateFlags &= ~DRAWING_CACHE_VALID;
			}
	do {		do {
	View view = null;		View view = null;
	if (parent instanceof View) {		if (parent instanceof View) {
	view = (View) parent;		view = (View) parent;
			if (view.mLayerType != LAYER_TYPE_NONE &&
			view.getParent() instanceof View) {
			final View grandParent = (View) view.getParent();
			grandParent.mPrivateFlags \|= INVALIDATED;
			grandParent.mPrivateFlags &= ~DRAWING_CACHE_VALID;
			}
	}		}

	if (drawAnimation) {		if (drawAnimation) {