Android/frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Remove support for density compatibility in the hardware renderer.

Browse Source 
Change-Id: I535e919986e5ccfb344ede8516ccd84c02642823
This commit is contained in:
Romain Guy
2010-07-09 10:36:05 -07:00
parent 831e550b49
commit dbd77cd444
5 changed files with 54 additions and 107 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
core/java/android/hardware/SensorEvent.java
View File

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

31
core/java/android/view/GLES20Canvas.java
View File

@@ -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,

23
core/java/android/view/HardwareRenderer.java
View File

@@ -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);
canvas.translate(0, -yOffset);
try {
canvas.translate(0, -yoff);
if (translator != null) {
translator.translateCanvas(canvas);
}
canvas.setDensity(density);
canvas.setScreenDensity(scalingRequired ? DisplayMetrics.DENSITY_DEVICE : 0);
view.draw(canvas);
} finally {
canvas.restoreToCount(saveCount);

2
core/java/android/view/ViewRoot.java
View File

@@ -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) {

101
core/jni/android_view_GLES20Canvas.cpp
View File

@@ -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) {
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();
}
OpenGLRenderer* renderer, SkBitmap* bitmap, float left, float top, SkPaint* paint) {
renderer->drawBitmap(bitmap, left, top, paint);
}
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) {
renderer->drawBitmap(bitmap, srcLeft, srcTop, srcRight, srcBottom,
dstLeft, dstTop, dstRight, dstBottom, paint);
} else {
// TODO: implement
}
float dstLeft, float dstTop, float dstRight, float dstBottom, SkPaint* paint) {
renderer->drawBitmap(bitmap, srcLeft, srcTop, srcRight, srcBottom,
dstLeft, dstTop, dstRight, dstBottom, paint);
}
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) {
renderer->drawBitmap(bitmap, matrix, paint);
} else {
// TODO: implement
}
OpenGLRenderer* renderer, SkBitmap* bitmap, SkMatrix* matrix, SkPaint* paint) {
renderer->drawBitmap(bitmap, matrix, paint);
}
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();
}
renderer->drawPatch(bitmap, patch, left, top, right, bottom, paint);
// TODO: make sure that 0 is correct for the flags
env->ReleaseByteArrayElements(chunks, storage, 0);
@@ -260,37 +227,37 @@ static void android_view_GLES20Canvas_drawRect(JNIEnv* env, jobject canvas,
const char* const kClassPathName = "android/view/GLES20Canvas";
static JNINativeMethod gMethods[] = {
{ "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 },
{ "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_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 },
{ "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_GLES20Canvas_saveLayer },
{ "nSaveLayerAlpha", "(IFFFFII)I", (void*) android_view_GLES20Canvas_saveLayerAlpha },
{ "nSaveLayer", "(IFFFFII)I", (void*) android_view_GLES20Canvas_saveLayer },
{ "nSaveLayerAlpha", "(IFFFFII)I", (void*) android_view_GLES20Canvas_saveLayerAlpha },
{ "nQuickReject", "(IFFFFI)Z", (void*) android_view_GLES20Canvas_quickReject },
{ "nClipRect", "(IFFFF)Z", (void*) android_view_GLES20Canvas_clipRectF },
{ "nClipRect", "(IIIII)Z", (void*) android_view_GLES20Canvas_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_GLES20Canvas_translate },
{ "nRotate", "(IF)V", (void*) android_view_GLES20Canvas_rotate },
{ "nScale", "(IFF)V", (void*) android_view_GLES20Canvas_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_GLES20Canvas_setMatrix },
{ "nGetMatrix", "(II)V", (void*) android_view_GLES20Canvas_getMatrix },
{ "nConcatMatrix", "(II)V", (void*) android_view_GLES20Canvas_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 },
{ "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 },
{ "nDrawColor", "(III)V", (void*) android_view_GLES20Canvas_drawColor },
{ "nDrawRect", "(IFFFFI)V", (void*) android_view_GLES20Canvas_drawRect },
{ "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 },
{ "nGetClipBounds", "(ILandroid/graphics/Rect;)Z",
(void*) android_view_GLES20Canvas_getClipBounds },