Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 0b1c17bd authored by John Reck's avatar John Reck Committed by Android Git Automerger
Browse files

am 01b321de: am 05dc201f: Merge "Remove Bitmap#getSkBitmap" into mnc-dev 

* commit '01b321de':
  Remove Bitmap#getSkBitmap
parents dd447382 01b321de

core/java/android/view/DisplayListCanvas.java

+3 −3
Original line number Diff line number Diff line
@@ -271,7 +271,7 @@ public class DisplayListCanvas extends Canvas { 
        Bitmap bitmap = patch.getBitmap();

        throwIfCannotDraw(bitmap);

        final long nativePaint = paint == null ? 0 : paint.getNativeInstance();

        nDrawPatch(mNativeCanvasWrapper, bitmap.getSkBitmap(), patch.mNativeChunk,

        nDrawPatch(mNativeCanvasWrapper, bitmap, patch.mNativeChunk,

                dst.left, dst.top, dst.right, dst.bottom, nativePaint);

    }
@@ -281,11 +281,11 @@ public class DisplayListCanvas extends Canvas { 
        Bitmap bitmap = patch.getBitmap();

        throwIfCannotDraw(bitmap);

        final long nativePaint = paint == null ? 0 : paint.getNativeInstance();

        nDrawPatch(mNativeCanvasWrapper, bitmap.getSkBitmap(), patch.mNativeChunk,

        nDrawPatch(mNativeCanvasWrapper, bitmap, patch.mNativeChunk,

                dst.left, dst.top, dst.right, dst.bottom, nativePaint);

    }



    private static native void nDrawPatch(long renderer, long bitmap, long chunk,

    private static native void nDrawPatch(long renderer, Bitmap bitmap, long chunk,

            float left, float top, float right, float bottom, long paint);



    public void drawCircle(CanvasProperty<Float> cx, CanvasProperty<Float> cy,

core/jni/android/graphics/NinePatch.cpp

+24 −21
Original line number Diff line number Diff line
@@ -64,7 +64,7 @@ public: 
        return JNI_FALSE;

    }



    static jlong validateNinePatchChunk(JNIEnv* env, jobject, jlong, jbyteArray obj) {

    static jlong validateNinePatchChunk(JNIEnv* env, jobject, jbyteArray obj) {

        size_t chunkSize = env->GetArrayLength(obj);

        if (chunkSize < (int) (sizeof(Res_png_9patch))) {

            jniThrowRuntimeException(env, "Array too small for chunk.");
@@ -88,13 +88,13 @@ public: 
        }

    }



    static void draw(JNIEnv* env, SkCanvas* canvas, SkRect& bounds, const SkBitmap* bitmap,

    static void draw(JNIEnv* env, SkCanvas* canvas, SkRect& bounds, const SkBitmap& bitmap,

            Res_png_9patch* chunk, const SkPaint* paint, jint destDensity, jint srcDensity) {

        if (destDensity == srcDensity || destDensity == 0 || srcDensity == 0) {

            ALOGV("Drawing unscaled 9-patch: (%g,%g)-(%g,%g)",

                    SkScalarToFloat(bounds.fLeft), SkScalarToFloat(bounds.fTop),

                    SkScalarToFloat(bounds.fRight), SkScalarToFloat(bounds.fBottom));

            NinePatch_Draw(canvas, bounds, *bitmap, *chunk, paint, NULL);

            NinePatch_Draw(canvas, bounds, bitmap, *chunk, paint, NULL);

        } else {

            canvas->save();
@@ -111,25 +111,25 @@ public: 
                    SkScalarToFloat(bounds.fRight), SkScalarToFloat(bounds.fBottom),

                    srcDensity, destDensity);



            NinePatch_Draw(canvas, bounds, *bitmap, *chunk, paint, NULL);

            NinePatch_Draw(canvas, bounds, bitmap, *chunk, paint, NULL);



            canvas->restore();

        }

    }



    static void drawF(JNIEnv* env, jobject, jlong canvasHandle, jobject boundsRectF,

            jlong bitmapHandle, jlong chunkHandle, jlong paintHandle,

            jobject jbitmap, jlong chunkHandle, jlong paintHandle,

            jint destDensity, jint srcDensity) {

        SkCanvas* canvas       = reinterpret_cast<Canvas*>(canvasHandle)->asSkCanvas();

        const SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle);

        Res_png_9patch* chunk  = reinterpret_cast<Res_png_9patch*>(chunkHandle);

        const Paint* paint     = reinterpret_cast<Paint*>(paintHandle);

        SkASSERT(canvas);

        SkASSERT(boundsRectF);

        SkASSERT(bitmap);

        SkASSERT(chunk);

        // paint is optional



        SkBitmap bitmap;

        GraphicsJNI::getSkBitmap(env, jbitmap, &bitmap);

        SkRect bounds;

        GraphicsJNI::jrectf_to_rect(env, boundsRectF, &bounds);
@@ -137,36 +137,36 @@ public: 
    }



    static void drawI(JNIEnv* env, jobject, jlong canvasHandle, jobject boundsRect,

            jlong bitmapHandle, jlong chunkHandle, jlong paintHandle,

            jobject jbitmap, jlong chunkHandle, jlong paintHandle,

            jint destDensity, jint srcDensity) {

        SkCanvas* canvas       = reinterpret_cast<Canvas*>(canvasHandle)->asSkCanvas();

        const SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle);

        Res_png_9patch* chunk  = reinterpret_cast<Res_png_9patch*>(chunkHandle);

        const Paint* paint     = reinterpret_cast<Paint*>(paintHandle);

        SkASSERT(canvas);

        SkASSERT(boundsRect);

        SkASSERT(bitmap);

        SkASSERT(chunk);

        // paint is optional



        SkBitmap bitmap;

        GraphicsJNI::getSkBitmap(env, jbitmap, &bitmap);

        SkRect bounds;

        GraphicsJNI::jrect_to_rect(env, boundsRect, &bounds);

        draw(env, canvas, bounds, bitmap, chunk, paint, destDensity, srcDensity);

    }



    static jlong getTransparentRegion(JNIEnv* env, jobject, jlong bitmapHandle,

    static jlong getTransparentRegion(JNIEnv* env, jobject, jobject jbitmap,

            jlong chunkHandle, jobject boundsRect) {

        const SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle);

        Res_png_9patch* chunk = reinterpret_cast<Res_png_9patch*>(chunkHandle);

        SkASSERT(bitmap);

        SkASSERT(chunk);

        SkASSERT(boundsRect);



        SkBitmap bitmap;

        GraphicsJNI::getSkBitmap(env, jbitmap, &bitmap);

        SkRect bounds;

        GraphicsJNI::jrect_to_rect(env, boundsRect, &bounds);



        SkRegion* region = NULL;

        NinePatch_Draw(NULL, bounds, *bitmap, *chunk, NULL, &region);

        NinePatch_Draw(NULL, bounds, bitmap, *chunk, NULL, &region);



        return reinterpret_cast<jlong>(region);

    }
@@ -177,11 +177,14 @@ public: 


static JNINativeMethod gNinePatchMethods[] = {

    { "isNinePatchChunk", "([B)Z", (void*) SkNinePatchGlue::isNinePatchChunk },

    { "validateNinePatchChunk", "(J[B)J",                 (void*) SkNinePatchGlue::validateNinePatchChunk },

    { "validateNinePatchChunk", "([B)J",

            (void*) SkNinePatchGlue::validateNinePatchChunk },

    { "nativeFinalize", "(J)V", (void*) SkNinePatchGlue::finalize },

    { "nativeDraw", "(JLandroid/graphics/RectF;JJJII)V",  (void*) SkNinePatchGlue::drawF },

    { "nativeDraw", "(JLandroid/graphics/Rect;JJJII)V",   (void*) SkNinePatchGlue::drawI },

    { "nativeGetTransparentRegion", "(JJLandroid/graphics/Rect;)J",

    { "nativeDraw", "(JLandroid/graphics/RectF;Landroid/graphics/Bitmap;JJII)V",

            (void*) SkNinePatchGlue::drawF },

    { "nativeDraw", "(JLandroid/graphics/Rect;Landroid/graphics/Bitmap;JJII)V",

            (void*) SkNinePatchGlue::drawI },

    { "nativeGetTransparentRegion", "(Landroid/graphics/Bitmap;JLandroid/graphics/Rect;)J",

            (void*) SkNinePatchGlue::getTransparentRegion }

};

core/jni/android_graphics_Canvas.cpp

+23 −19
Original line number Diff line number Diff line
@@ -318,11 +318,12 @@ static void drawVertices(JNIEnv* env, jobject, jlong canvasHandle, 
                                           indices, indexCount, *paint);

}



static void drawBitmap(JNIEnv* env, jobject jcanvas, jlong canvasHandle, jlong bitmapHandle,

static void drawBitmap(JNIEnv* env, jobject jcanvas, jlong canvasHandle, jobject jbitmap,

                       jfloat left, jfloat top, jlong paintHandle, jint canvasDensity,

                       jint screenDensity, jint bitmapDensity) {

    Canvas* canvas = get_canvas(canvasHandle);

    const SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle);

    SkBitmap bitmap;

    GraphicsJNI::getSkBitmap(env, jbitmap, &bitmap);

    const Paint* paint = reinterpret_cast<Paint*>(paintHandle);



    if (canvasDensity == bitmapDensity || canvasDensity == 0 || bitmapDensity == 0) {
@@ -332,9 +333,9 @@ static void drawBitmap(JNIEnv* env, jobject jcanvas, jlong canvasHandle, jlong b 
                filteredPaint = *paint;

            }

            filteredPaint.setFilterQuality(kLow_SkFilterQuality);

            canvas->drawBitmap(*bitmap, left, top, &filteredPaint);

            canvas->drawBitmap(bitmap, left, top, &filteredPaint);

        } else {

            canvas->drawBitmap(*bitmap, left, top, paint);

            canvas->drawBitmap(bitmap, left, top, paint);

        }

    } else {

        canvas->save(SkCanvas::kMatrixClip_SaveFlag);
@@ -348,37 +349,39 @@ static void drawBitmap(JNIEnv* env, jobject jcanvas, jlong canvasHandle, jlong b 
        }

        filteredPaint.setFilterQuality(kLow_SkFilterQuality);



        canvas->drawBitmap(*bitmap, 0, 0, &filteredPaint);

        canvas->drawBitmap(bitmap, 0, 0, &filteredPaint);

        canvas->restore();

    }

}



static void drawBitmapMatrix(JNIEnv* env, jobject, jlong canvasHandle, jlong bitmapHandle,

static void drawBitmapMatrix(JNIEnv* env, jobject, jlong canvasHandle, jobject jbitmap,

                             jlong matrixHandle, jlong paintHandle) {

    const SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle);

    const SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixHandle);

    const Paint* paint = reinterpret_cast<Paint*>(paintHandle);

    get_canvas(canvasHandle)->drawBitmap(*bitmap, *matrix, paint);

    SkBitmap bitmap;

    GraphicsJNI::getSkBitmap(env, jbitmap, &bitmap);

    get_canvas(canvasHandle)->drawBitmap(bitmap, *matrix, paint);

}



static void drawBitmapRect(JNIEnv* env, jobject, jlong canvasHandle, jlong bitmapHandle,

static void drawBitmapRect(JNIEnv* env, jobject, jlong canvasHandle, jobject jbitmap,

                           float srcLeft, float srcTop, float srcRight, float srcBottom,

                           float dstLeft, float dstTop, float dstRight, float dstBottom,

                           jlong paintHandle, jint screenDensity, jint bitmapDensity) {

    Canvas* canvas = get_canvas(canvasHandle);

    const SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle);

    const Paint* paint = reinterpret_cast<Paint*>(paintHandle);



    SkBitmap bitmap;

    GraphicsJNI::getSkBitmap(env, jbitmap, &bitmap);

    if (screenDensity != 0 && screenDensity != bitmapDensity) {

        Paint filteredPaint;

        if (paint) {

            filteredPaint = *paint;

        }

        filteredPaint.setFilterQuality(kLow_SkFilterQuality);

        canvas->drawBitmap(*bitmap, srcLeft, srcTop, srcRight, srcBottom,

        canvas->drawBitmap(bitmap, srcLeft, srcTop, srcRight, srcBottom,

                           dstLeft, dstTop, dstRight, dstBottom, &filteredPaint);

    } else {

        canvas->drawBitmap(*bitmap, srcLeft, srcTop, srcRight, srcBottom,

        canvas->drawBitmap(bitmap, srcLeft, srcTop, srcRight, srcBottom,

                           dstLeft, dstTop, dstRight, dstBottom, paint);

    }

}
@@ -406,16 +409,17 @@ static void drawBitmapArray(JNIEnv* env, jobject, jlong canvasHandle, 
    get_canvas(canvasHandle)->drawBitmap(bitmap, x, y, paint);

}



static void drawBitmapMesh(JNIEnv* env, jobject, jlong canvasHandle, jlong bitmapHandle,

static void drawBitmapMesh(JNIEnv* env, jobject, jlong canvasHandle, jobject jbitmap,

                           jint meshWidth, jint meshHeight, jfloatArray jverts,

                           jint vertIndex, jintArray jcolors, jint colorIndex, jlong paintHandle) {

    const int ptCount = (meshWidth + 1) * (meshHeight + 1);

    AutoJavaFloatArray vertA(env, jverts, vertIndex + (ptCount << 1));

    AutoJavaIntArray colorA(env, jcolors, colorIndex + ptCount);



    const SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle);

    const Paint* paint = reinterpret_cast<Paint*>(paintHandle);

    get_canvas(canvasHandle)->drawBitmapMesh(*bitmap, meshWidth, meshHeight,

    SkBitmap bitmap;

    GraphicsJNI::getSkBitmap(env, jbitmap, &bitmap);

    get_canvas(canvasHandle)->drawBitmapMesh(bitmap, meshWidth, meshHeight,

                                             vertA.ptr(), colorA.ptr(), paint);

}
@@ -700,11 +704,11 @@ static JNINativeMethod gMethods[] = { 
    {"native_drawArc","(JFFFFFFZJ)V", (void*) CanvasJNI::drawArc},

    {"native_drawPath","(JJJ)V", (void*) CanvasJNI::drawPath},

    {"nativeDrawVertices", "(JII[FI[FI[II[SIIJ)V", (void*)CanvasJNI::drawVertices},

    {"native_drawBitmap","(JJFFJIII)V", (void*) CanvasJNI::drawBitmap},

    {"nativeDrawBitmapMatrix", "(JJJJ)V", (void*)CanvasJNI::drawBitmapMatrix},

    {"native_drawBitmap","(JJFFFFFFFFJII)V", (void*) CanvasJNI::drawBitmapRect},

    {"native_drawBitmap","(JLandroid/graphics/Bitmap;FFJIII)V", (void*) CanvasJNI::drawBitmap},

    {"nativeDrawBitmapMatrix", "(JLandroid/graphics/Bitmap;JJ)V", (void*)CanvasJNI::drawBitmapMatrix},

    {"native_drawBitmap","(JLandroid/graphics/Bitmap;FFFFFFFFJII)V", (void*) CanvasJNI::drawBitmapRect},

    {"native_drawBitmap", "(J[IIIFFIIZJ)V", (void*)CanvasJNI::drawBitmapArray},

    {"nativeDrawBitmapMesh", "(JJII[FI[IIJ)V", (void*)CanvasJNI::drawBitmapMesh},

    {"nativeDrawBitmapMesh", "(JLandroid/graphics/Bitmap;II[FI[IIJ)V", (void*)CanvasJNI::drawBitmapMesh},

    {"native_drawText","(J[CIIFFIJJ)V", (void*) CanvasJNI::drawTextChars},

    {"native_drawText","(JLjava/lang/String;IIFFIJJ)V", (void*) CanvasJNI::drawTextString},

    {"native_drawTextRun","(J[CIIIIFFZJJ)V", (void*) CanvasJNI::drawTextRunChars},

core/jni/android_view_DisplayListCanvas.cpp

+4 −4
Original line number Diff line number Diff line
@@ -132,10 +132,10 @@ static jint android_view_DisplayListCanvas_getMaxTextureHeight(JNIEnv* env, jobj 
// ----------------------------------------------------------------------------



static void android_view_DisplayListCanvas_drawPatch(JNIEnv* env, jobject clazz,

        jlong rendererPtr, jlong bitmapPtr, jlong patchPtr,

        jlong rendererPtr, jobject jbitmap, jlong patchPtr,

        float left, float top, float right, float bottom, jlong paintPtr) {

    SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapPtr);



    SkBitmap bitmap;

    GraphicsJNI::getSkBitmap(env, jbitmap, &bitmap);

    DisplayListCanvas* renderer = reinterpret_cast<DisplayListCanvas*>(rendererPtr);

    Res_png_9patch* patch = reinterpret_cast<Res_png_9patch*>(patchPtr);

    Paint* paint = reinterpret_cast<Paint*>(paintPtr);
@@ -273,7 +273,7 @@ static JNINativeMethod gMethods[] = { 


    { "nCallDrawGLFunction", "(JJ)V",          (void*) android_view_DisplayListCanvas_callDrawGLFunction },



    { "nDrawPatch",         "(JJJFFFFJ)V",     (void*) android_view_DisplayListCanvas_drawPatch },

    { "nDrawPatch",         "(JLandroid/graphics/Bitmap;JFFFFJ)V",     (void*) android_view_DisplayListCanvas_drawPatch },



    { "nDrawRects",         "(JJJ)V",          (void*) android_view_DisplayListCanvas_drawRegionAsRects },

    { "nDrawRoundRect",     "(JJJJJJJJ)V",     (void*) android_view_DisplayListCanvas_drawRoundRectProps },

graphics/java/android/graphics/Bitmap.java

+0 −5
Original line number Diff line number Diff line
@@ -1568,11 +1568,6 @@ public final class Bitmap implements Parcelable { 
        nativePrepareToDraw(mSkBitmapPtr);

    }



    /** @hide */

    public final long getSkBitmap() {

        return mSkBitmapPtr;

    }



    /**

     * Refs the underlying SkPixelRef and returns a pointer to it.

     *