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

core/java/android/view/GLES20Canvas.java

+41 −17

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

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

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

		@Override
		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
		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
		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
		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
		public void drawBitmap(int[] colors, int offset, int stride, float x, float y,
		int width, int height, boolean hasAlpha, Paint paint) {
		@@ -386,14 +410,12 @@ class GLES20Canvas extends Canvas {
		@Override
		public void drawBitmap(int[] colors, int offset, int stride, int x, int y,
		int width, int height, boolean hasAlpha, Paint paint) {

		// TODO: Implement
		drawBitmap(colors, offset, stride, (float) x, (float) y, width, height, hasAlpha, paint);
		}

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

		throw new UnsupportedOperationException();
		}

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

		@Override
		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
		@@ -426,7 +452,7 @@ class GLES20Canvas extends Canvas {

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

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

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

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

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

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

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

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

		throw new UnsupportedOperationException();
		}

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

		throw new UnsupportedOperationException();
		}

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

		throw new UnsupportedOperationException();
		}

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

		throw new UnsupportedOperationException();
		}
		}

core/java/android/view/HardwareRenderer.java

+5 −2

Original line number	Diff line number	Diff line
		@@ -76,10 +76,12 @@ abstract class HardwareRenderer {
		* @param attachInfo AttachInfo tied to the specified view.
		* @param translator Translator used to draw applications in compatibility mode.
		* @param yoff The vertical offset for the drawing.
		* @param density The density of the application
		* @param scalingRequired Whether drawing should be scaled.
		*/
		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
		@@ -370,7 +372,7 @@ abstract class HardwareRenderer {

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

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

		view.draw(canvas);

core/java/android/view/ViewRoot.java

+1 −1

Original line number	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 (!dirty.isEmpty()) {
		mHwRenderer.draw(mView, mAttachInfo, mTranslator, yoff, scalingRequired);
		mHwRenderer.draw(mView, mAttachInfo, mTranslator, yoff, mDensity, scalingRequired);
		}

		if (scrolling) {

core/jni/android_view_GLES20Canvas.cpp

+74 −47

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

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

		static OpenGLRenderer* android_view_GLES20Renderer_createRenderer(JNIEnv* env, jobject canvas) {
		static OpenGLRenderer* android_view_GLES20Canvas_createRenderer(JNIEnv* env, jobject canvas) {
		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) {
		delete renderer;
		}
		@@ -57,12 +58,12 @@ static void android_view_GLES20Renderer_destroyRenderer(JNIEnv* env, jobject can
		// 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) {
		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) {
		renderer->prepare();
		}
		@@ -71,22 +72,22 @@ static void android_view_GLES20Renderer_prepare(JNIEnv* env, jobject canvas,
		// 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) {
		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) {
		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) {
		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) {
		renderer->restoreToCount(saveCount);
		}
		@@ -95,13 +96,13 @@ static void android_view_GLES20Renderer_restoreToCount(JNIEnv* env, jobject canv
		// 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,
		SkPaint* paint, jint 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,
		jint alpha, jint 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
		// ----------------------------------------------------------------------------

		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,
		SkCanvas::EdgeType edge) {
		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) {
		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) {
		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) {

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

		env->CallVoidMethod(rect, gRectClassInfo.set,
		@@ -142,32 +142,32 @@ static bool android_view_GLES20Renderer_getClipBounds(JNIEnv* env, jobject canva
		// 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) {
		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) {
		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) {
		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) {
		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) {
		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) {
		renderer->concatMatrix(matrix);
		}
		@@ -176,12 +176,37 @@ static void android_view_GLES20Renderer_concatMatrix(JNIEnv* env, jobject canvas
		// Drawing
		// ----------------------------------------------------------------------------

		static void android_view_GLES20Renderer_drawColor(JNIEnv* env, jobject canvas,
		OpenGLRenderer* renderer, jint color, jint mode) {
		renderer->drawColor(color, (SkXfermode::Mode) mode);
		static void android_view_GLES20Canvas_drawBitmap(JNIEnv* env, jobject canvas,
		OpenGLRenderer* renderer, SkBitmap* bitmap, float left, float top,
		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,
		SkPaint* 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";

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

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

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

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

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

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

		{ "nDrawColor", "(III)V", (void*) android_view_GLES20Renderer_drawColor },
		{ "nDrawRect", "(IFFFFI)V", (void*) android_view_GLES20Renderer_drawRect },
		{ "nDrawBitmap", "(IIFFIIII)V", (void*) android_view_GLES20Canvas_drawBitmap },
		{ "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",
		(void*) android_view_GLES20Renderer_getClipBounds },
		(void*) android_view_GLES20Canvas_getClipBounds },
		};

		#define FIND_CLASS(var, className) \

graphics/java/android/graphics/Bitmap.java

+7 −3

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

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

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