Remove support for density compatibility in the hardware renderer. (dbd77cd4) · Commits · e / os / android_frameworks_base

core/java/android/hardware/SensorEvent.java

+2 −2

Original line number	Diff line number	Diff line
		@@ -84,14 +84,14 @@ public class SensorEvent {
		* sensor itself (<b>Fs</b>) using the relation:
		* </p>
		*
		* <b><center>Ad = - ·Fs / mass</center></b>
		* <b><center>Ad = - ∑Fs / mass</center></b>
		*
		* <p>
		* In particular, the force of gravity is always influencing the measured
		* acceleration:
		* </p>
		*
		* <b><center>Ad = -g - ·F / mass</center></b>
		* <b><center>Ad = -g - ∑F / mass</center></b>
		*
		* <p>
		* For this reason, when the device is sitting on a table (and obviously not

core/java/android/view/GLES20Canvas.java

+13 −18

Original line number	Diff line number	Diff line
		@@ -362,53 +362,48 @@ class GLES20Canvas extends Canvas {
		@Override
		public void drawPatch(Bitmap bitmap, byte[] chunks, RectF dst, Paint paint) {
		final int nativePaint = paint == null ? 0 : paint.mNativePaint;
		nDrawPatch(mRenderer, bitmap.mNativeBitmap, chunks, dst.left, dst.top, dst.right,
		dst.bottom, nativePaint, bitmap.getDensity(), mDensity, mScreenDensity);
		nDrawPatch(mRenderer, bitmap.mNativeBitmap, chunks, dst.left, dst.top,
		dst.right, dst.bottom, nativePaint);
		}

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

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

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

		@Override
		public void drawBitmap(Bitmap bitmap, Matrix matrix, Paint paint) {
		final int nativePaint = paint == null ? 0 : paint.mNativePaint;
		nDrawBitmap(mRenderer, bitmap.mNativeBitmap, matrix.native_instance, nativePaint,
		bitmap.getDensity(), mDensity, mScreenDensity);
		nDrawBitmap(mRenderer, bitmap.mNativeBitmap, matrix.native_instance, nativePaint);
		}

		private native void nDrawBitmap(int renderer, int bitmap, int matrix, int paint,
		int bitmapDensity, int canvasDensity, int screenDensity);
		private native void nDrawBitmap(int renderer, int bitmap, int matrix, int paint);

		@Override
		public void drawBitmap(Bitmap bitmap, Rect src, Rect dst, Paint paint) {
		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, nativePaint,
		bitmap.getDensity(), mDensity, mScreenDensity);
		dst.left, dst.top, dst.right, dst.bottom, nativePaint
		);
		}

		@Override
		public void drawBitmap(Bitmap bitmap, Rect src, RectF dst, Paint paint) {
		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, nativePaint,
		bitmap.getDensity(), mDensity, mScreenDensity);
		dst.left, dst.top, dst.right, dst.bottom, nativePaint
		);
		}

		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 paint,
		int bitmapDensity, int canvasDensity, int screenDensity);
		float left, float top, float right, float bottom, int paint);

		@Override
		public void drawBitmap(int[] colors, int offset, int stride, float x, float y,

core/java/android/view/HardwareRenderer.java

+4 −19

Original line number	Diff line number	Diff line
		@@ -17,10 +17,8 @@

		package android.view;

		import android.content.res.CompatibilityInfo;
		import android.graphics.Canvas;
		import android.os.SystemClock;
		import android.util.DisplayMetrics;
		import android.util.Log;

		import javax.microedition.khronos.egl.EGL10;
		@@ -74,14 +72,8 @@ abstract class HardwareRenderer {
		*
		* @param view The view to draw.
		* @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, int density,
		boolean scalingRequired);
		abstract void draw(View view, View.AttachInfo attachInfo, int yOffset);

		/**
		* Initializes the hardware renderer for the specified surface and setup the
		@@ -371,9 +363,7 @@ abstract class HardwareRenderer {
		}

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

		void draw(View view, View.AttachInfo attachInfo, int yOffset) {
		if (canDraw()) {
		attachInfo.mDrawingTime = SystemClock.uptimeMillis();
		attachInfo.mIgnoreDirtyState = true;
		@@ -383,14 +373,9 @@ abstract class HardwareRenderer {

		Canvas canvas = mCanvas;
		int saveCount = canvas.save(Canvas.MATRIX_SAVE_FLAG);
		try {
		canvas.translate(0, -yoff);
		if (translator != null) {
		translator.translateCanvas(canvas);
		}
		canvas.setDensity(density);
		canvas.setScreenDensity(scalingRequired ? DisplayMetrics.DENSITY_DEVICE : 0);
		canvas.translate(0, -yOffset);

		try {
		view.draw(canvas);
		} finally {
		canvas.restoreToCount(saveCount);

core/java/android/view/ViewRoot.java

+1 −1

Original line number	Diff line number	Diff line
		@@ -1262,7 +1262,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, mDensity, scalingRequired);
		mHwRenderer.draw(mView, mAttachInfo, yoff);
		}

		if (scrolling) {

core/jni/android_view_GLES20Canvas.cpp

+40 −73

Original line number	Diff line number	Diff line
		@@ -178,65 +178,32 @@ static void android_view_GLES20Canvas_concatMatrix(JNIEnv* env, jobject canvas,
		// ----------------------------------------------------------------------------

		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) {
		OpenGLRenderer* renderer, SkBitmap* bitmap, float left, float top, SkPaint* paint) {
		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,
		SkPaint* paint, jint bitmapDensity, jint canvasDensity, jint screenDensity) {
		if (canvasDensity == bitmapDensity \|\| canvasDensity == 0 \|\| bitmapDensity == 0) {
		float dstLeft, float dstTop, float dstRight, float dstBottom, SkPaint* paint) {
		renderer->drawBitmap(bitmap, srcLeft, srcTop, srcRight, srcBottom,
		dstLeft, dstTop, dstRight, dstBottom, paint);
		} else {
		// TODO: implement
		}
		}

		static void android_view_GLES20Canvas_drawBitmapMatrix(JNIEnv* env, jobject canvas,
		OpenGLRenderer* renderer, SkBitmap* bitmap, SkMatrix* matrix, SkPaint* paint,
		jint bitmapDensity, jint canvasDensity,jint screenDensity) {
		if (canvasDensity == bitmapDensity \|\| canvasDensity == 0 \|\| bitmapDensity == 0) {
		OpenGLRenderer* renderer, SkBitmap* bitmap, SkMatrix* matrix, SkPaint* paint) {
		renderer->drawBitmap(bitmap, matrix, paint);
		} else {
		// TODO: implement
		}
		}

		static void android_view_GLES20Canvas_drawPatch(JNIEnv* env, jobject canvas,
		OpenGLRenderer* renderer, SkBitmap* bitmap, jbyteArray chunks,
		float left, float top, float right, float bottom, SkPaint* paint,
		jint bitmapDensity, jint canvasDensity,jint screenDensity) {
		float left, float top, float right, float bottom, SkPaint* paint) {

		jbyte* storage = env->GetByteArrayElements(chunks, NULL);
		Res_png_9patch* patch = reinterpret_cast<Res_png_9patch*>(storage);
		Res_png_9patch::deserialize(patch);

		if (canvasDensity == bitmapDensity \|\| canvasDensity == 0 \|\| bitmapDensity == 0) {
		renderer->drawPatch(bitmap, patch, left, top, right, bottom, paint);
		} else {
		renderer->save(0);
		const float scale = canvasDensity / float(bitmapDensity);
		renderer->translate(left, top);
		renderer->scale(scale, scale);
		left = top = 0.0f;
		right = (right - left) / scale;
		bottom = (bottom - top) / scale;
		renderer->drawPatch(bitmap, patch, left, top, right, bottom, paint);
		renderer->restore();
		}

		// TODO: make sure that 0 is correct for the flags
		env->ReleaseByteArrayElements(chunks, storage, 0);
		@@ -285,10 +252,10 @@ static JNINativeMethod gMethods[] = {
		{ "nGetMatrix", "(II)V", (void*) android_view_GLES20Canvas_getMatrix },
		{ "nConcatMatrix", "(II)V", (void*) android_view_GLES20Canvas_concatMatrix },

		{ "nDrawBitmap", "(IIFFIIII)V", (void*) android_view_GLES20Canvas_drawBitmap },
		{ "nDrawBitmap", "(IIFFFFFFFFIIII)V", (void*) android_view_GLES20Canvas_drawBitmapRect },
		{ "nDrawBitmap", "(IIIIIII)V", (void*) android_view_GLES20Canvas_drawBitmapMatrix },
		{ "nDrawPatch", "(II[BFFFFIIII)V", (void*) android_view_GLES20Canvas_drawPatch },
		{ "nDrawBitmap", "(IIFFI)V", (void*) android_view_GLES20Canvas_drawBitmap },
		{ "nDrawBitmap", "(IIFFFFFFFFI)V", (void*) android_view_GLES20Canvas_drawBitmapRect },
		{ "nDrawBitmap", "(IIII)V", (void*) android_view_GLES20Canvas_drawBitmapMatrix },
		{ "nDrawPatch", "(II[BFFFFI)V", (void*) android_view_GLES20Canvas_drawPatch },
		{ "nDrawColor", "(III)V", (void*) android_view_GLES20Canvas_drawColor },
		{ "nDrawRect", "(IFFFFI)V", (void*) android_view_GLES20Canvas_drawRect },