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	Original line	Diff line number	Diff line
	@@ -84,14 +84,14 @@ public class SensorEvent {
	* sensor itself (<b>Fs</b>) using the relation:		* sensor itself (<b>Fs</b>) using the relation:
	* </p>		* </p>
	*		*
	* <b><center>Ad = - ·Fs / mass</center></b>		* <b><center>Ad = - ∑Fs / mass</center></b>
	*		*
	* <p>		* <p>
	* In particular, the force of gravity is always influencing the measured		* In particular, the force of gravity is always influencing the measured
	* acceleration:		* acceleration:
	* </p>		* </p>
	*		*
	* <b><center>Ad = -g - ·F / mass</center></b>		* <b><center>Ad = -g - ∑F / mass</center></b>
	*		*
	* <p>		* <p>
	* For this reason, when the device is sitting on a table (and obviously not		* 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	Original line	Diff line number	Diff line
	@@ -362,53 +362,48 @@ class GLES20Canvas extends Canvas {
	@Override		@Override
	public void drawPatch(Bitmap bitmap, byte[] chunks, RectF dst, Paint paint) {		public void drawPatch(Bitmap bitmap, byte[] chunks, RectF dst, Paint paint) {
	final int nativePaint = paint == null ? 0 : paint.mNativePaint;		final int nativePaint = paint == null ? 0 : paint.mNativePaint;
	nDrawPatch(mRenderer, bitmap.mNativeBitmap, chunks, dst.left, dst.top, dst.right,		nDrawPatch(mRenderer, bitmap.mNativeBitmap, chunks, dst.left, dst.top,
	dst.bottom, nativePaint, bitmap.getDensity(), mDensity, mScreenDensity);		dst.right, dst.bottom, nativePaint);
	}		}

	private native void nDrawPatch(int renderer, int bitmap, byte[] chunks, float left, float top,		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		@Override
	public void drawBitmap(Bitmap bitmap, float left, float top, Paint paint) {		public void drawBitmap(Bitmap bitmap, float left, float top, Paint paint) {
	final int nativePaint = paint == null ? 0 : paint.mNativePaint;		final int nativePaint = paint == null ? 0 : paint.mNativePaint;
	nDrawBitmap(mRenderer, bitmap.mNativeBitmap, left, top, nativePaint,		nDrawBitmap(mRenderer, bitmap.mNativeBitmap, left, top, nativePaint);
	bitmap.getDensity(), mDensity, mScreenDensity);
	}		}

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

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

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

	@Override		@Override
	public void drawBitmap(Bitmap bitmap, Rect src, Rect dst, Paint paint) {		public void drawBitmap(Bitmap bitmap, Rect src, Rect dst, Paint paint) {
	final int nativePaint = paint == null ? 0 : paint.mNativePaint;		final int nativePaint = paint == null ? 0 : paint.mNativePaint;
	nDrawBitmap(mRenderer, bitmap.mNativeBitmap, src.left, src.top, src.right, src.bottom,		nDrawBitmap(mRenderer, bitmap.mNativeBitmap, src.left, src.top, src.right, src.bottom,
	dst.left, dst.top, dst.right, dst.bottom, nativePaint,		dst.left, dst.top, dst.right, dst.bottom, 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) {
	final int nativePaint = paint == null ? 0 : paint.mNativePaint;		final int nativePaint = paint == null ? 0 : paint.mNativePaint;
	nDrawBitmap(mRenderer, bitmap.mNativeBitmap, src.left, src.top, src.right, src.bottom,		nDrawBitmap(mRenderer, bitmap.mNativeBitmap, src.left, src.top, src.right, src.bottom,
	dst.left, dst.top, dst.right, dst.bottom, nativePaint,		dst.left, dst.top, dst.right, dst.bottom, 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,		private native void nDrawBitmap(int renderer, int bitmap,
	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);
	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,

core/java/android/view/HardwareRenderer.java

+4 −19

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

	package android.view;		package android.view;

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

	import javax.microedition.khronos.egl.EGL10;		import javax.microedition.khronos.egl.EGL10;
	@@ -74,14 +72,8 @@ 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 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,		abstract void draw(View view, View.AttachInfo attachInfo, int yOffset);
	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
	@@ -371,9 +363,7 @@ abstract class HardwareRenderer {
	}		}

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

	if (canDraw()) {		if (canDraw()) {
	attachInfo.mDrawingTime = SystemClock.uptimeMillis();		attachInfo.mDrawingTime = SystemClock.uptimeMillis();
	attachInfo.mIgnoreDirtyState = true;		attachInfo.mIgnoreDirtyState = true;
	@@ -383,14 +373,9 @@ abstract class HardwareRenderer {

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

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

core/java/android/view/ViewRoot.java

+1 −1

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

	if (scrolling) {		if (scrolling) {

core/jni/android_view_GLES20Canvas.cpp

+40 −73

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

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

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

	jbyte* storage = env->GetByteArrayElements(chunks, NULL);		jbyte* storage = env->GetByteArrayElements(chunks, NULL);
	Res_png_9patch* patch = reinterpret_cast<Res_png_9patch*>(storage);		Res_png_9patch* patch = reinterpret_cast<Res_png_9patch*>(storage);
	Res_png_9patch::deserialize(patch);		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->drawPatch(bitmap, patch, left, top, right, bottom, paint);
	renderer->restore();
	}

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

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