Merge "Add hooks for drawBitmap()." (68e9a49a) · Commits · e / os / android_frameworks_base

core/java/android/view/GLES20Canvas.java

+41 −17

Original line number	Original line	Diff line number	Diff line
	@@ -43,6 +43,9 @@ class GLES20Canvas extends Canvas {
	private int mWidth;		private int mWidth;
	private int mHeight;		private int mHeight;

			private final float[] mPoint = new float[2];
			private final float[] mLine = new float[4];

	///////////////////////////////////////////////////////////////////////////		///////////////////////////////////////////////////////////////////////////
	// Constructors		// Constructors
	///////////////////////////////////////////////////////////////////////////		///////////////////////////////////////////////////////////////////////////
	@@ -358,24 +361,45 @@ class GLES20Canvas extends Canvas {

	@Override		@Override
	public void drawBitmap(Bitmap bitmap, float left, float top, Paint paint) {		public void drawBitmap(Bitmap bitmap, float left, float top, Paint paint) {
	// TODO: Implement		final int nativePaint = paint == null ? 0 : paint.mNativePaint;
			nDrawBitmap(mRenderer, bitmap.mNativeBitmap, left, top, nativePaint,
			bitmap.getDensity(), mDensity, mScreenDensity);
	}		}

	@Override		@Override
	public void drawBitmap(Bitmap bitmap, Matrix matrix, Paint paint) {		public void drawBitmap(Bitmap bitmap, Matrix matrix, Paint paint) {
	// TODO: Implement		final float width = bitmap.getWidth();
			final float height = bitmap.getHeight();
			final int nativePaint = paint == null ? 0 : paint.mNativePaint;
			nDrawBitmap(mRenderer, bitmap.mNativeBitmap, 0.0f, 0.0f, width, height,
			0.0f, 0.0f, width, height, matrix.native_instance, nativePaint,
			bitmap.getDensity(), mDensity, mScreenDensity);
	}		}

	@Override		@Override
	public void drawBitmap(Bitmap bitmap, Rect src, Rect dst, Paint paint) {		public void drawBitmap(Bitmap bitmap, Rect src, Rect dst, Paint paint) {
	// TODO: Implement		final int nativePaint = paint == null ? 0 : paint.mNativePaint;
			nDrawBitmap(mRenderer, bitmap.mNativeBitmap, src.left, src.top, src.right, src.bottom,
			dst.left, dst.top, dst.right, dst.bottom, 0, nativePaint,
			bitmap.getDensity(), mDensity, mScreenDensity);
	}		}

	@Override		@Override
	public void drawBitmap(Bitmap bitmap, Rect src, RectF dst, Paint paint) {		public void drawBitmap(Bitmap bitmap, Rect src, RectF dst, Paint paint) {
	// TODO: Implement		final int nativePaint = paint == null ? 0 : paint.mNativePaint;
			nDrawBitmap(mRenderer, bitmap.mNativeBitmap, src.left, src.top, src.right, src.bottom,
			dst.left, dst.top, dst.right, dst.bottom, 0, nativePaint,
			bitmap.getDensity(), mDensity, mScreenDensity);
	}		}

			private native void nDrawBitmap(int renderer, int bitmap, float left, float top, int paint,
			int bitmapDensity, int canvasDensity, int screenDensity);

			private native void nDrawBitmap(int renderer, int bitmap,
			float srcLeft, float srcTop, float srcRight, float srcBottom,
			float left, float top, float right, float bottom, int matrix, int paint,
			int bitmapDensity, int canvasDensity, int screenDensity);

	@Override		@Override
	public void drawBitmap(int[] colors, int offset, int stride, float x, float y,		public void drawBitmap(int[] colors, int offset, int stride, float x, float y,
	int width, int height, boolean hasAlpha, Paint paint) {		int width, int height, boolean hasAlpha, Paint paint) {
	@@ -386,14 +410,12 @@ class GLES20Canvas extends Canvas {
	@Override		@Override
	public void drawBitmap(int[] colors, int offset, int stride, int x, int y,		public void drawBitmap(int[] colors, int offset, int stride, int x, int y,
	int width, int height, boolean hasAlpha, Paint paint) {		int width, int height, boolean hasAlpha, Paint paint) {
			drawBitmap(colors, offset, stride, (float) x, (float) y, width, height, hasAlpha, paint);
	// TODO: Implement
	}		}

	@Override		@Override
	public void drawBitmapMesh(Bitmap bitmap, int meshWidth, int meshHeight, float[] verts,		public void drawBitmapMesh(Bitmap bitmap, int meshWidth, int meshHeight, float[] verts,
	int vertOffset, int[] colors, int colorOffset, Paint paint) {		int vertOffset, int[] colors, int colorOffset, Paint paint) {

	throw new UnsupportedOperationException();		throw new UnsupportedOperationException();
	}		}

	@@ -416,7 +438,11 @@ class GLES20Canvas extends Canvas {

	@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) {
	// TODO: Implement		mLine[0] = startX;
			mLine[1] = startY;
			mLine[2] = stopX;
			mLine[3] = stopY;
			drawLines(mLine, 0, 1, paint);
	}		}

	@Override		@Override
	@@ -426,7 +452,7 @@ class GLES20Canvas extends Canvas {

	@Override		@Override
	public void drawLines(float[] pts, Paint paint) {		public void drawLines(float[] pts, Paint paint) {
	// TODO: Implement		drawLines(pts, 0, pts.length / 4, paint);
	}		}

	@Override		@Override
	@@ -461,7 +487,9 @@ class GLES20Canvas extends Canvas {

	@Override		@Override
	public void drawPoint(float x, float y, Paint paint) {		public void drawPoint(float x, float y, Paint paint) {
	// TODO: Implement		mPoint[0] = x;
			mPoint[1] = y;
			drawPoints(mPoint, 0, 1, paint);
	}		}

	@Override		@Override
	@@ -471,7 +499,7 @@ class GLES20Canvas extends Canvas {

	@Override		@Override
	public void drawPoints(float[] pts, Paint paint) {		public void drawPoints(float[] pts, Paint paint) {
	// TODO: Implement		drawPoints(pts, 0, pts.length / 2, paint);
	}		}

	@Override		@Override
	@@ -529,13 +557,12 @@ class GLES20Canvas extends Canvas {

	@Override		@Override
	public void drawText(String text, float x, float y, Paint paint) {		public void drawText(String text, float x, float y, Paint paint) {
	// TODO: Implement		drawText(text, 0, text.length(), x, y, paint);
	}		}

	@Override		@Override
	public void drawTextOnPath(char[] text, int index, int count, Path path, float hOffset,		public void drawTextOnPath(char[] text, int index, int count, Path path, float hOffset,
	float vOffset, Paint paint) {		float vOffset, Paint paint) {

	throw new UnsupportedOperationException();		throw new UnsupportedOperationException();
	}		}

	@@ -547,14 +574,12 @@ class GLES20Canvas extends Canvas {
	@Override		@Override
	public void drawTextRun(char[] text, int index, int count, int contextIndex, int contextCount,		public void drawTextRun(char[] text, int index, int count, int contextIndex, int contextCount,
	float x, float y, int dir, Paint paint) {		float x, float y, int dir, Paint paint) {

	throw new UnsupportedOperationException();		throw new UnsupportedOperationException();
	}		}

	@Override		@Override
	public void drawTextRun(CharSequence text, int start, int end, int contextStart, int contextEnd,		public void drawTextRun(CharSequence text, int start, int end, int contextStart, int contextEnd,
	float x, float y, int dir, Paint paint) {		float x, float y, int dir, Paint paint) {

	throw new UnsupportedOperationException();		throw new UnsupportedOperationException();
	}		}

	@@ -562,7 +587,6 @@ class GLES20Canvas extends Canvas {
	public void drawVertices(VertexMode mode, int vertexCount, float[] verts, int vertOffset,		public void drawVertices(VertexMode mode, int vertexCount, float[] verts, int vertOffset,
	float[] texs, int texOffset, int[] colors, int colorOffset, short[] indices,		float[] texs, int texOffset, int[] colors, int colorOffset, short[] indices,
	int indexOffset, int indexCount, Paint paint) {		int indexOffset, int indexCount, Paint paint) {

	throw new UnsupportedOperationException();		throw new UnsupportedOperationException();
	}		}
	}		}

core/java/android/view/HardwareRenderer.java

+5 −2

Original line number	Original line	Diff line number	Diff line
	@@ -76,10 +76,12 @@ abstract class HardwareRenderer {
	* @param attachInfo AttachInfo tied to the specified view.		* @param attachInfo AttachInfo tied to the specified view.
	* @param translator Translator used to draw applications in compatibility mode.		* @param translator Translator used to draw applications in compatibility mode.
	* @param yoff The vertical offset for the drawing.		* @param yoff The vertical offset for the drawing.
			* @param density The density of the application
	* @param scalingRequired Whether drawing should be scaled.		* @param scalingRequired Whether drawing should be scaled.
	*/		*/
	abstract void draw(View view, View.AttachInfo attachInfo,		abstract void draw(View view, View.AttachInfo attachInfo,
	CompatibilityInfo.Translator translator, int yoff, boolean scalingRequired);		CompatibilityInfo.Translator translator, int yoff, int density,
			boolean scalingRequired);

	/**		/**
	* Initializes the hardware renderer for the specified surface and setup the		* Initializes the hardware renderer for the specified surface and setup the
	@@ -370,7 +372,7 @@ abstract class HardwareRenderer {

	@Override		@Override
	void draw(View view, View.AttachInfo attachInfo, CompatibilityInfo.Translator translator,		void draw(View view, View.AttachInfo attachInfo, CompatibilityInfo.Translator translator,
	int yoff, boolean scalingRequired) {		int yoff, int density, boolean scalingRequired) {

	if (canDraw()) {		if (canDraw()) {
	attachInfo.mDrawingTime = SystemClock.uptimeMillis();		attachInfo.mDrawingTime = SystemClock.uptimeMillis();
	@@ -386,6 +388,7 @@ abstract class HardwareRenderer {
	if (translator != null) {		if (translator != null) {
	translator.translateCanvas(canvas);		translator.translateCanvas(canvas);
	}		}
			canvas.setDensity(density);
	canvas.setScreenDensity(scalingRequired ? DisplayMetrics.DENSITY_DEVICE : 0);		canvas.setScreenDensity(scalingRequired ? DisplayMetrics.DENSITY_DEVICE : 0);

	view.draw(canvas);		view.draw(canvas);

core/java/android/view/ViewRoot.java

+1 −1

Original line number	Original line	Diff line number	Diff line
	@@ -1264,7 +1264,7 @@ public final class ViewRoot extends Handler implements ViewParent, View.AttachIn

	if (mHwRenderer != null && mHwRenderer.isEnabled()) {		if (mHwRenderer != null && mHwRenderer.isEnabled()) {
	if (!dirty.isEmpty()) {		if (!dirty.isEmpty()) {
	mHwRenderer.draw(mView, mAttachInfo, mTranslator, yoff, scalingRequired);		mHwRenderer.draw(mView, mAttachInfo, mTranslator, yoff, mDensity, scalingRequired);
	}		}

	if (scrolling) {		if (scrolling) {

core/jni/android_view_GLES20Canvas.cpp

+74 −47

Original line number	Original line	Diff line number	Diff line
	@@ -18,6 +18,7 @@
	#include <nativehelper/JNIHelp.h>		#include <nativehelper/JNIHelp.h>
	#include <android_runtime/AndroidRuntime.h>		#include <android_runtime/AndroidRuntime.h>

			#include <SkBitmap.h>
	#include <SkCanvas.h>		#include <SkCanvas.h>
	#include <SkMatrix.h>		#include <SkMatrix.h>
	#include <SkPaint.h>		#include <SkPaint.h>
	@@ -44,11 +45,11 @@ static struct {
	// Constructors		// Constructors
	// ----------------------------------------------------------------------------		// ----------------------------------------------------------------------------

	static OpenGLRenderer* android_view_GLES20Renderer_createRenderer(JNIEnv* env, jobject canvas) {		static OpenGLRenderer* android_view_GLES20Canvas_createRenderer(JNIEnv* env, jobject canvas) {
	return new OpenGLRenderer;		return new OpenGLRenderer;
	}		}

	static void android_view_GLES20Renderer_destroyRenderer(JNIEnv* env, jobject canvas,		static void android_view_GLES20Canvas_destroyRenderer(JNIEnv* env, jobject canvas,
	OpenGLRenderer* renderer) {		OpenGLRenderer* renderer) {
	delete renderer;		delete renderer;
	}		}
	@@ -57,12 +58,12 @@ static void android_view_GLES20Renderer_destroyRenderer(JNIEnv* env, jobject can
	// Setup		// Setup
	// ----------------------------------------------------------------------------		// ----------------------------------------------------------------------------

	static void android_view_GLES20Renderer_setViewport(JNIEnv* env, jobject canvas,		static void android_view_GLES20Canvas_setViewport(JNIEnv* env, jobject canvas,
	OpenGLRenderer* renderer, jint width, jint height) {		OpenGLRenderer* renderer, jint width, jint height) {
	renderer->setViewport(width, height);		renderer->setViewport(width, height);
	}		}

	static void android_view_GLES20Renderer_prepare(JNIEnv* env, jobject canvas,		static void android_view_GLES20Canvas_prepare(JNIEnv* env, jobject canvas,
	OpenGLRenderer* renderer) {		OpenGLRenderer* renderer) {
	renderer->prepare();		renderer->prepare();
	}		}
	@@ -71,22 +72,22 @@ static void android_view_GLES20Renderer_prepare(JNIEnv* env, jobject canvas,
	// State		// State
	// ----------------------------------------------------------------------------		// ----------------------------------------------------------------------------

	static jint android_view_GLES20Renderer_save(JNIEnv* env, jobject canvas, OpenGLRenderer* renderer,		static jint android_view_GLES20Canvas_save(JNIEnv* env, jobject canvas, OpenGLRenderer* renderer,
	jint flags) {		jint flags) {
	return renderer->save(flags);		return renderer->save(flags);
	}		}

	static jint android_view_GLES20Renderer_getSaveCount(JNIEnv* env, jobject canvas,		static jint android_view_GLES20Canvas_getSaveCount(JNIEnv* env, jobject canvas,
	OpenGLRenderer* renderer) {		OpenGLRenderer* renderer) {
	return renderer->getSaveCount();		return renderer->getSaveCount();
	}		}

	static void android_view_GLES20Renderer_restore(JNIEnv* env, jobject canvas,		static void android_view_GLES20Canvas_restore(JNIEnv* env, jobject canvas,
	OpenGLRenderer* renderer) {		OpenGLRenderer* renderer) {
	renderer->restore();		renderer->restore();
	}		}

	static void android_view_GLES20Renderer_restoreToCount(JNIEnv* env, jobject canvas,		static void android_view_GLES20Canvas_restoreToCount(JNIEnv* env, jobject canvas,
	OpenGLRenderer* renderer, jint saveCount) {		OpenGLRenderer* renderer, jint saveCount) {
	renderer->restoreToCount(saveCount);		renderer->restoreToCount(saveCount);
	}		}
	@@ -95,13 +96,13 @@ static void android_view_GLES20Renderer_restoreToCount(JNIEnv* env, jobject canv
	// Layers		// Layers
	// ----------------------------------------------------------------------------		// ----------------------------------------------------------------------------

	static jint android_view_GLES20Renderer_saveLayer(JNIEnv* env, jobject canvas,		static jint android_view_GLES20Canvas_saveLayer(JNIEnv* env, jobject canvas,
	OpenGLRenderer* renderer, jfloat left, jfloat top, jfloat right, jfloat bottom,		OpenGLRenderer* renderer, jfloat left, jfloat top, jfloat right, jfloat bottom,
	SkPaint* paint, jint saveFlags) {		SkPaint* paint, jint saveFlags) {
	return renderer->saveLayer(left, top, right, bottom, paint, saveFlags);		return renderer->saveLayer(left, top, right, bottom, paint, saveFlags);
	}		}

	static jint android_view_GLES20Renderer_saveLayerAlpha(JNIEnv* env, jobject canvas,		static jint android_view_GLES20Canvas_saveLayerAlpha(JNIEnv* env, jobject canvas,
	OpenGLRenderer* renderer, jfloat left, jfloat top, jfloat right, jfloat bottom,		OpenGLRenderer* renderer, jfloat left, jfloat top, jfloat right, jfloat bottom,
	jint alpha, jint saveFlags) {		jint alpha, jint saveFlags) {
	return renderer->saveLayerAlpha(left, top, right, bottom, alpha, saveFlags);		return renderer->saveLayerAlpha(left, top, right, bottom, alpha, saveFlags);
	@@ -111,25 +112,24 @@ static jint android_view_GLES20Renderer_saveLayerAlpha(JNIEnv* env, jobject canv
	// Clipping		// Clipping
	// ----------------------------------------------------------------------------		// ----------------------------------------------------------------------------

	static bool android_view_GLES20Renderer_quickReject(JNIEnv* env, jobject canvas,		static bool android_view_GLES20Canvas_quickReject(JNIEnv* env, jobject canvas,
	OpenGLRenderer* renderer, jfloat left, jfloat top, jfloat right, jfloat bottom,		OpenGLRenderer* renderer, jfloat left, jfloat top, jfloat right, jfloat bottom,
	SkCanvas::EdgeType edge) {		SkCanvas::EdgeType edge) {
	return renderer->quickReject(left, top, right, bottom);		return renderer->quickReject(left, top, right, bottom);
	}		}

	static bool android_view_GLES20Renderer_clipRectF(JNIEnv* env, jobject canvas,		static bool android_view_GLES20Canvas_clipRectF(JNIEnv* env, jobject canvas,
	OpenGLRenderer* renderer, jfloat left, jfloat top, jfloat right, jfloat bottom) {		OpenGLRenderer* renderer, jfloat left, jfloat top, jfloat right, jfloat bottom) {
	return renderer->clipRect(left, top, right, bottom);		return renderer->clipRect(left, top, right, bottom);
	}		}

	static bool android_view_GLES20Renderer_clipRect(JNIEnv* env, jobject canvas,		static bool android_view_GLES20Canvas_clipRect(JNIEnv* env, jobject canvas,
	OpenGLRenderer* renderer, jint left, jint top, jint right, jint bottom) {		OpenGLRenderer* renderer, jint left, jint top, jint right, jint bottom) {
	return renderer->clipRect(float(left), float(top), float(right), float(bottom));		return renderer->clipRect(float(left), float(top), float(right), float(bottom));
	}		}

	static bool android_view_GLES20Renderer_getClipBounds(JNIEnv* env, jobject canvas,		static bool android_view_GLES20Canvas_getClipBounds(JNIEnv* env, jobject canvas,
	OpenGLRenderer* renderer, jobject rect) {		OpenGLRenderer* renderer, jobject rect) {

	const android::uirenderer::Rect& bounds(renderer->getClipBounds());		const android::uirenderer::Rect& bounds(renderer->getClipBounds());

	env->CallVoidMethod(rect, gRectClassInfo.set,		env->CallVoidMethod(rect, gRectClassInfo.set,
	@@ -142,32 +142,32 @@ static bool android_view_GLES20Renderer_getClipBounds(JNIEnv* env, jobject canva
	// Transforms		// Transforms
	// ----------------------------------------------------------------------------		// ----------------------------------------------------------------------------

	static void android_view_GLES20Renderer_translate(JNIEnv* env, jobject canvas,		static void android_view_GLES20Canvas_translate(JNIEnv* env, jobject canvas,
	OpenGLRenderer* renderer, jfloat dx, jfloat dy) {		OpenGLRenderer* renderer, jfloat dx, jfloat dy) {
	renderer->translate(dx, dy);		renderer->translate(dx, dy);
	}		}

	static void android_view_GLES20Renderer_rotate(JNIEnv* env, jobject canvas,		static void android_view_GLES20Canvas_rotate(JNIEnv* env, jobject canvas,
	OpenGLRenderer* renderer, jfloat degrees) {		OpenGLRenderer* renderer, jfloat degrees) {
	renderer->rotate(degrees);		renderer->rotate(degrees);
	}		}

	static void android_view_GLES20Renderer_scale(JNIEnv* env, jobject canvas,		static void android_view_GLES20Canvas_scale(JNIEnv* env, jobject canvas,
	OpenGLRenderer* renderer, jfloat sx, jfloat sy) {		OpenGLRenderer* renderer, jfloat sx, jfloat sy) {
	renderer->scale(sx, sy);		renderer->scale(sx, sy);
	}		}

	static void android_view_GLES20Renderer_setMatrix(JNIEnv* env, jobject canvas,		static void android_view_GLES20Canvas_setMatrix(JNIEnv* env, jobject canvas,
	OpenGLRenderer* renderer, SkMatrix* matrix) {		OpenGLRenderer* renderer, SkMatrix* matrix) {
	renderer->setMatrix(matrix);		renderer->setMatrix(matrix);
	}		}

	static void android_view_GLES20Renderer_getMatrix(JNIEnv* env, jobject canvas,		static void android_view_GLES20Canvas_getMatrix(JNIEnv* env, jobject canvas,
	OpenGLRenderer* renderer, SkMatrix* matrix) {		OpenGLRenderer* renderer, SkMatrix* matrix) {
	renderer->getMatrix(matrix);		renderer->getMatrix(matrix);
	}		}

	static void android_view_GLES20Renderer_concatMatrix(JNIEnv* env, jobject canvas,		static void android_view_GLES20Canvas_concatMatrix(JNIEnv* env, jobject canvas,
	OpenGLRenderer* renderer, SkMatrix* matrix) {		OpenGLRenderer* renderer, SkMatrix* matrix) {
	renderer->concatMatrix(matrix);		renderer->concatMatrix(matrix);
	}		}
	@@ -176,12 +176,37 @@ static void android_view_GLES20Renderer_concatMatrix(JNIEnv* env, jobject canvas
	// Drawing		// Drawing
	// ----------------------------------------------------------------------------		// ----------------------------------------------------------------------------

	static void android_view_GLES20Renderer_drawColor(JNIEnv* env, jobject canvas,		static void android_view_GLES20Canvas_drawBitmap(JNIEnv* env, jobject canvas,
	OpenGLRenderer* renderer, jint color, jint mode) {		OpenGLRenderer* renderer, SkBitmap* bitmap, float left, float top,
	renderer->drawColor(color, (SkXfermode::Mode) mode);		SkPaint* paint, jint bitmapDensity, jint canvasDensity,jint screenDensity) {
			if (canvasDensity == bitmapDensity \|\| canvasDensity == 0 \|\| bitmapDensity == 0) {
			renderer->drawBitmap(bitmap, left, top, paint);
			} else {
			renderer->save(0);
			const float scale = canvasDensity / float(bitmapDensity);
			renderer->translate(left, top);
			renderer->scale(scale, scale);
			renderer->drawBitmap(bitmap, left, top, paint);
			renderer->restore();
			}
			}

			static void android_view_GLES20Canvas_drawBitmapRect(JNIEnv* env, jobject canvas,
			OpenGLRenderer* renderer, SkBitmap* bitmap,
			float srcLeft, float srcTop, float srcRight, float srcBottom,
			float dstLeft, float dstTop, float dstRight, float dstBottom,
			SkMatrix* matrix, SkPaint* paint,
			jint bitmapDenstiy, jint canvasDensity, jint screenDensity) {
			// TODO: Implement!
			LOGE("Not implemented: drawBitmap(IIFFFFFFFFIIIII)V");
			}

			static void android_view_GLES20Canvas_drawColor(JNIEnv* env, jobject canvas,
			OpenGLRenderer* renderer, jint color, SkXfermode::Mode mode) {
			renderer->drawColor(color, mode);
	}		}

	static void android_view_GLES20Renderer_drawRect(JNIEnv* env, jobject canvas,		static void android_view_GLES20Canvas_drawRect(JNIEnv* env, jobject canvas,
	OpenGLRenderer* renderer, jfloat left, jfloat top, jfloat right, jfloat bottom,		OpenGLRenderer* renderer, jfloat left, jfloat top, jfloat right, jfloat bottom,
	SkPaint* paint) {		SkPaint* paint) {
	renderer->drawRect(left, top, right, bottom, paint);		renderer->drawRect(left, top, right, bottom, paint);
	@@ -194,36 +219,38 @@ static void android_view_GLES20Renderer_drawRect(JNIEnv* env, jobject canvas,
	const char* const kClassPathName = "android/view/GLES20Canvas";		const char* const kClassPathName = "android/view/GLES20Canvas";

	static JNINativeMethod gMethods[] = {		static JNINativeMethod gMethods[] = {
	{ "nCreateRenderer", "()I", (void*) android_view_GLES20Renderer_createRenderer },		{ "nCreateRenderer", "()I", (void*) android_view_GLES20Canvas_createRenderer },
	{ "nDestroyRenderer", "(I)V", (void*) android_view_GLES20Renderer_destroyRenderer },		{ "nDestroyRenderer", "(I)V", (void*) android_view_GLES20Canvas_destroyRenderer },
	{ "nSetViewport", "(III)V", (void*) android_view_GLES20Renderer_setViewport },		{ "nSetViewport", "(III)V", (void*) android_view_GLES20Canvas_setViewport },
	{ "nPrepare", "(I)V", (void*) android_view_GLES20Renderer_prepare },		{ "nPrepare", "(I)V", (void*) android_view_GLES20Canvas_prepare },

	{ "nSave", "(II)I", (void*) android_view_GLES20Renderer_save },		{ "nSave", "(II)I", (void*) android_view_GLES20Canvas_save },
	{ "nRestore", "(I)V", (void*) android_view_GLES20Renderer_restore },		{ "nRestore", "(I)V", (void*) android_view_GLES20Canvas_restore },
	{ "nRestoreToCount", "(II)V", (void*) android_view_GLES20Renderer_restoreToCount },		{ "nRestoreToCount", "(II)V", (void*) android_view_GLES20Canvas_restoreToCount },
	{ "nGetSaveCount", "(I)I", (void*) android_view_GLES20Renderer_getSaveCount },		{ "nGetSaveCount", "(I)I", (void*) android_view_GLES20Canvas_getSaveCount },

	{ "nSaveLayer", "(IFFFFII)I", (void*) android_view_GLES20Renderer_saveLayer },		{ "nSaveLayer", "(IFFFFII)I", (void*) android_view_GLES20Canvas_saveLayer },
	{ "nSaveLayerAlpha", "(IFFFFII)I", (void*) android_view_GLES20Renderer_saveLayerAlpha },		{ "nSaveLayerAlpha", "(IFFFFII)I", (void*) android_view_GLES20Canvas_saveLayerAlpha },

	{ "nQuickReject", "(IFFFFI)Z", (void*) android_view_GLES20Renderer_quickReject },		{ "nQuickReject", "(IFFFFI)Z", (void*) android_view_GLES20Canvas_quickReject },
	{ "nClipRect", "(IFFFF)Z", (void*) android_view_GLES20Renderer_clipRectF },		{ "nClipRect", "(IFFFF)Z", (void*) android_view_GLES20Canvas_clipRectF },
	{ "nClipRect", "(IIIII)Z", (void*) android_view_GLES20Renderer_clipRect },		{ "nClipRect", "(IIIII)Z", (void*) android_view_GLES20Canvas_clipRect },

	{ "nTranslate", "(IFF)V", (void*) android_view_GLES20Renderer_translate },		{ "nTranslate", "(IFF)V", (void*) android_view_GLES20Canvas_translate },
	{ "nRotate", "(IF)V", (void*) android_view_GLES20Renderer_rotate },		{ "nRotate", "(IF)V", (void*) android_view_GLES20Canvas_rotate },
	{ "nScale", "(IFF)V", (void*) android_view_GLES20Renderer_scale },		{ "nScale", "(IFF)V", (void*) android_view_GLES20Canvas_scale },

	{ "nSetMatrix", "(II)V", (void*) android_view_GLES20Renderer_setMatrix },		{ "nSetMatrix", "(II)V", (void*) android_view_GLES20Canvas_setMatrix },
	{ "nGetMatrix", "(II)V", (void*) android_view_GLES20Renderer_getMatrix },		{ "nGetMatrix", "(II)V", (void*) android_view_GLES20Canvas_getMatrix },
	{ "nConcatMatrix", "(II)V", (void*) android_view_GLES20Renderer_concatMatrix },		{ "nConcatMatrix", "(II)V", (void*) android_view_GLES20Canvas_concatMatrix },

	{ "nDrawColor", "(III)V", (void*) android_view_GLES20Renderer_drawColor },		{ "nDrawBitmap", "(IIFFIIII)V", (void*) android_view_GLES20Canvas_drawBitmap },
	{ "nDrawRect", "(IFFFFI)V", (void*) android_view_GLES20Renderer_drawRect },		{ "nDrawBitmap", "(IIFFFFFFFFIIIII)V", (void*) android_view_GLES20Canvas_drawBitmapRect },
			{ "nDrawColor", "(III)V", (void*) android_view_GLES20Canvas_drawColor },
			{ "nDrawRect", "(IFFFFI)V", (void*) android_view_GLES20Canvas_drawRect },

	{ "nGetClipBounds", "(ILandroid/graphics/Rect;)Z",		{ "nGetClipBounds", "(ILandroid/graphics/Rect;)Z",
	(void*) android_view_GLES20Renderer_getClipBounds },		(void*) android_view_GLES20Canvas_getClipBounds },
	};		};

	#define FIND_CLASS(var, className) \		#define FIND_CLASS(var, className) \

graphics/java/android/graphics/Bitmap.java

+7 −3

Original line number	Original line	Diff line number	Diff line
	@@ -35,9 +35,13 @@ public final class Bitmap implements Parcelable {
	*/		*/
	public static final int DENSITY_NONE = 0;		public static final int DENSITY_NONE = 0;

	// Note: mNativeBitmap is used by FaceDetector_jni.cpp		/**
	// Don't change/rename without updating FaceDetector_jni.cpp		* Note: mNativeBitmap is used by FaceDetector_jni.cpp
	private final int mNativeBitmap;		* Don't change/rename without updating FaceDetector_jni.cpp
			*
			* @hide
			*/
			public final int mNativeBitmap;

	private final boolean mIsMutable;		private final boolean mIsMutable;
	private byte[] mNinePatchChunk; // may be null		private byte[] mNinePatchChunk; // may be null