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

Commit f7681f84 authored by Wei-Ta Chen's avatar Wei-Ta Chen
Browse files

Do not merge. 

Fix 3052285 by not publishing the BitmapRegionDecoder API until the honeycomb release.

Bug: 3052285
Change-Id: Ie339e414c1a5581e1d38684621e0e97162616977
parent e619a9da

api/current.xml

+2 −142
Original line number Diff line number Diff line
@@ -63056,146 +63056,6 @@ 
>

</field>

</class>

<class name="BitmapRegionDecoder"

 extends="java.lang.Object"

 abstract="false"

 static="false"

 final="true"

 deprecated="not deprecated"

 visibility="public"

>

<method name="decodeRegion"

 return="android.graphics.Bitmap"

 abstract="false"

 native="false"

 synchronized="false"

 static="false"

 final="false"

 deprecated="not deprecated"

 visibility="public"

>

<parameter name="rect" type="android.graphics.Rect">

</parameter>

<parameter name="options" type="android.graphics.BitmapFactory.Options">

</parameter>

</method>

<method name="getHeight"

 return="int"

 abstract="false"

 native="false"

 synchronized="false"

 static="false"

 final="false"

 deprecated="not deprecated"

 visibility="public"

>

</method>

<method name="getWidth"

 return="int"

 abstract="false"

 native="false"

 synchronized="false"

 static="false"

 final="false"

 deprecated="not deprecated"

 visibility="public"

>

</method>

<method name="isRecycled"

 return="boolean"

 abstract="false"

 native="false"

 synchronized="false"

 static="false"

 final="true"

 deprecated="not deprecated"

 visibility="public"

>

</method>

<method name="newInstance"

 return="android.graphics.BitmapRegionDecoder"

 abstract="false"

 native="false"

 synchronized="false"

 static="true"

 final="false"

 deprecated="not deprecated"

 visibility="public"

>

<parameter name="data" type="byte[]">

</parameter>

<parameter name="offset" type="int">

</parameter>

<parameter name="length" type="int">

</parameter>

<parameter name="isShareable" type="boolean">

</parameter>

<exception name="IOException" type="java.io.IOException">

</exception>

</method>

<method name="newInstance"

 return="android.graphics.BitmapRegionDecoder"

 abstract="false"

 native="false"

 synchronized="false"

 static="true"

 final="false"

 deprecated="not deprecated"

 visibility="public"

>

<parameter name="fd" type="java.io.FileDescriptor">

</parameter>

<parameter name="isShareable" type="boolean">

</parameter>

<exception name="IOException" type="java.io.IOException">

</exception>

</method>

<method name="newInstance"

 return="android.graphics.BitmapRegionDecoder"

 abstract="false"

 native="false"

 synchronized="false"

 static="true"

 final="false"

 deprecated="not deprecated"

 visibility="public"

>

<parameter name="is" type="java.io.InputStream">

</parameter>

<parameter name="isShareable" type="boolean">

</parameter>

<exception name="IOException" type="java.io.IOException">

</exception>

</method>

<method name="newInstance"

 return="android.graphics.BitmapRegionDecoder"

 abstract="false"

 native="false"

 synchronized="false"

 static="true"

 final="false"

 deprecated="not deprecated"

 visibility="public"

>

<parameter name="pathName" type="java.lang.String">

</parameter>

<parameter name="isShareable" type="boolean">

</parameter>

<exception name="IOException" type="java.io.IOException">

</exception>

</method>

<method name="recycle"

 return="void"

 abstract="false"

 native="false"

 synchronized="false"

 static="false"

 final="false"

 deprecated="not deprecated"

 visibility="public"

>

</method>

</class>

<class name="BitmapShader"

 extends="android.graphics.Shader"

 abstract="false"
@@ -79357,7 +79217,7 @@ 
 type="float"

 transient="false"

 volatile="false"

 value="0.0010f"

 value="0.001f"

 static="true"

 final="true"

 deprecated="not deprecated"
@@ -225068,7 +224928,7 @@ 
 deprecated="not deprecated"

 visibility="public"

>

<parameter name="t" type="T">

<parameter name="arg0" type="T">

</parameter>

</method>

</interface>

core/jni/Android.mk

+0 −1
Original line number Diff line number Diff line
@@ -101,7 +101,6 @@ LOCAL_SRC_FILES:= \ 
	android_graphics_PixelFormat.cpp \

	android/graphics/Picture.cpp \

	android/graphics/PorterDuff.cpp \

	android/graphics/BitmapRegionDecoder.cpp \

	android/graphics/Rasterizer.cpp \

	android/graphics/Region.cpp \

	android/graphics/Shader.cpp \

core/jni/AndroidRuntime.cpp

+0 −2
Original line number Diff line number Diff line
@@ -53,7 +53,6 @@ extern int register_android_os_Binder(JNIEnv* env); 
extern int register_android_os_Process(JNIEnv* env);

extern int register_android_graphics_Bitmap(JNIEnv*);

extern int register_android_graphics_BitmapFactory(JNIEnv*);

extern int register_android_graphics_BitmapRegionDecoder(JNIEnv*);

extern int register_android_graphics_Camera(JNIEnv* env);

extern int register_android_graphics_Graphics(JNIEnv* env);

extern int register_android_graphics_Interpolator(JNIEnv* env);
@@ -1220,7 +1219,6 @@ static const RegJNIRec gRegJNI[] = { 


    REG_JNI(register_android_graphics_Bitmap),

    REG_JNI(register_android_graphics_BitmapFactory),

    REG_JNI(register_android_graphics_BitmapRegionDecoder),

    REG_JNI(register_android_graphics_Camera),

    REG_JNI(register_android_graphics_Canvas),

    REG_JNI(register_android_graphics_ColorFilter),

core/jni/android/graphics/BitmapRegionDecoder.cpp

deleted100644 → 0
+0 −305
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2010 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */



#define LOG_TAG "BitmapRegionDecoder"



#include "SkBitmap.h"

#include "SkImageEncoder.h"

#include "GraphicsJNI.h"

#include "SkUtils.h"

#include "SkTemplates.h"

#include "SkPixelRef.h"

#include "SkStream.h"

#include "BitmapFactory.h"

#include "AutoDecodeCancel.h"

#include "SkBitmapRegionDecoder.h"

#include "CreateJavaOutputStreamAdaptor.h"

#include "Utils.h"



#include <android_runtime/AndroidRuntime.h>

#include "android_util_Binder.h"

#include "android_nio_utils.h"

#include "CreateJavaOutputStreamAdaptor.h"



#include <binder/Parcel.h>

#include <jni.h>

#include <utils/Asset.h>

#include <sys/stat.h>



static jclass gFileDescriptor_class;

static jfieldID gFileDescriptor_descriptor;



#if 0

    #define TRACE_BITMAP(code)  code

#else

    #define TRACE_BITMAP(code)

#endif



using namespace android;



static SkMemoryStream* buildSkMemoryStream(SkStream *stream) {

    size_t bufferSize = 4096;

    size_t streamLen = 0;

    size_t len;

    char* data = (char*)sk_malloc_throw(bufferSize);



    while ((len = stream->read(data + streamLen,

                    bufferSize - streamLen)) != 0) {

        streamLen += len;

        if (streamLen == bufferSize) {

            bufferSize *= 2;

            data = (char*)sk_realloc_throw(data, bufferSize);

        }

    }

    data = (char*)sk_realloc_throw(data, streamLen);

    SkMemoryStream* streamMem = new SkMemoryStream();

    streamMem->setMemoryOwned(data, streamLen);

    return streamMem;

}



static jobject doBuildTileIndex(JNIEnv* env, SkStream* stream) {

    SkImageDecoder* decoder = SkImageDecoder::Factory(stream);

    int width, height;

    if (NULL == decoder) {

        doThrowIOE(env, "Image format not supported");

        return nullObjectReturn("SkImageDecoder::Factory returned null");

    }



    JavaPixelAllocator *javaAllocator = new JavaPixelAllocator(env, true);

    decoder->setAllocator(javaAllocator);

    JavaMemoryUsageReporter *javaMemoryReporter = new JavaMemoryUsageReporter(env);

    decoder->setReporter(javaMemoryReporter);

    javaAllocator->unref();

    javaMemoryReporter->unref();



    if (!decoder->buildTileIndex(stream, &width, &height)) {

        char msg[100];

        snprintf(msg, sizeof(msg), "Image failed to decode using %s decoder",

                decoder->getFormatName());

        doThrowIOE(env, msg);

        return nullObjectReturn("decoder->buildTileIndex returned false");

    }



    SkBitmapRegionDecoder *bm = new SkBitmapRegionDecoder(decoder, width, height);



    return GraphicsJNI::createBitmapRegionDecoder(env, bm);

}



static jobject nativeNewInstanceFromByteArray(JNIEnv* env, jobject, jbyteArray byteArray,

                                     int offset, int length, jboolean isShareable) {

    /*  If isShareable we could decide to just wrap the java array and

        share it, but that means adding a globalref to the java array object

        For now we just always copy the array's data if isShareable.

     */

    AutoJavaByteArray ar(env, byteArray);

    SkStream* stream = new SkMemoryStream(ar.ptr() + offset, length, true);

    return doBuildTileIndex(env, stream);

}



static jobject nativeNewInstanceFromFileDescriptor(JNIEnv* env, jobject clazz,

                                          jobject fileDescriptor, jboolean isShareable) {

    NPE_CHECK_RETURN_ZERO(env, fileDescriptor);



    jint descriptor = env->GetIntField(fileDescriptor,

                                       gFileDescriptor_descriptor);

    SkStream *stream = NULL;

    struct stat fdStat;

    int newFD;

    if (fstat(descriptor, &fdStat) == -1) {

        doThrowIOE(env, "broken file descriptor");

        return nullObjectReturn("fstat return -1");

    }



    if (isShareable &&

            S_ISREG(fdStat.st_mode) &&

            (newFD = ::dup(descriptor)) != -1) {

        SkFDStream* fdStream = new SkFDStream(newFD, true);

        if (!fdStream->isValid()) {

            fdStream->unref();

            return NULL;

        }

        stream = fdStream;

    } else {

        SkFDStream* fdStream = new SkFDStream(descriptor, false);

        if (!fdStream->isValid()) {

            fdStream->unref();

            return NULL;

        }

        stream = buildSkMemoryStream(fdStream);

        fdStream->unref();

    }



    /* Restore our offset when we leave, so we can be called more than once

       with the same descriptor. This is only required if we didn't dup the

       file descriptor, but it is OK to do it all the time.

    */

    AutoFDSeek as(descriptor);



    return doBuildTileIndex(env, stream);

}



static jobject nativeNewInstanceFromStream(JNIEnv* env, jobject clazz,

                                  jobject is,       // InputStream

                                  jbyteArray storage, // byte[]

                                  jboolean isShareable) {

    jobject largeBitmap = NULL;

    SkStream* stream = CreateJavaInputStreamAdaptor(env, is, storage, 1024);



    if (stream) {

        // for now we don't allow shareable with java inputstreams

        SkMemoryStream *mStream = buildSkMemoryStream(stream);

        largeBitmap = doBuildTileIndex(env, mStream);

        stream->unref();

    }

    return largeBitmap;

}



static jobject nativeNewInstanceFromAsset(JNIEnv* env, jobject clazz,

                                 jint native_asset, // Asset

                                 jboolean isShareable) {

    SkStream* stream, *assStream;

    Asset* asset = reinterpret_cast<Asset*>(native_asset);

    assStream = new AssetStreamAdaptor(asset);

    stream = buildSkMemoryStream(assStream);

    assStream->unref();

    return doBuildTileIndex(env, stream);

}



/*

 * nine patch not supported

 *

 * purgeable not supported

 * reportSizeToVM not supported

 */

static jobject nativeDecodeRegion(JNIEnv* env, jobject, SkBitmapRegionDecoder *brd,

        int start_x, int start_y, int width, int height, jobject options) {

    SkImageDecoder *decoder = brd->getDecoder();

    int sampleSize = 1;

    SkBitmap::Config prefConfig = SkBitmap::kNo_Config;

    bool doDither = true;



    if (NULL != options) {

        sampleSize = env->GetIntField(options, gOptions_sampleSizeFieldID);

        // initialize these, in case we fail later on

        env->SetIntField(options, gOptions_widthFieldID, -1);

        env->SetIntField(options, gOptions_heightFieldID, -1);

        env->SetObjectField(options, gOptions_mimeFieldID, 0);



        jobject jconfig = env->GetObjectField(options, gOptions_configFieldID);

        prefConfig = GraphicsJNI::getNativeBitmapConfig(env, jconfig);

        doDither = env->GetBooleanField(options, gOptions_ditherFieldID);

    }



    decoder->setDitherImage(doDither);

    SkBitmap*           bitmap = new SkBitmap;

    SkAutoTDelete<SkBitmap>       adb(bitmap);

    AutoDecoderCancel   adc(options, decoder);



    // To fix the race condition in case "requestCancelDecode"

    // happens earlier than AutoDecoderCancel object is added

    // to the gAutoDecoderCancelMutex linked list.

    if (NULL != options && env->GetBooleanField(options, gOptions_mCancelID)) {

        return nullObjectReturn("gOptions_mCancelID");;

    }



    SkIRect region;

    region.fLeft = start_x;

    region.fTop = start_y;

    region.fRight = start_x + width;

    region.fBottom = start_y + height;



    if (!brd->decodeRegion(bitmap, region, prefConfig, sampleSize)) {

        return nullObjectReturn("decoder->decodeRegion returned false");

    }



    // update options (if any)

    if (NULL != options) {

        env->SetIntField(options, gOptions_widthFieldID, bitmap->width());

        env->SetIntField(options, gOptions_heightFieldID, bitmap->height());

        // TODO: set the mimeType field with the data from the codec.

        // but how to reuse a set of strings, rather than allocating new one

        // each time?

        env->SetObjectField(options, gOptions_mimeFieldID,

                            getMimeTypeString(env, decoder->getFormat()));

    }



    // detach bitmap from its autotdeleter, since we want to own it now

    adb.detach();



    SkPixelRef* pr;

    pr = bitmap->pixelRef();

    // promise we will never change our pixels (great for sharing and pictures)

    pr->setImmutable();

    // now create the java bitmap

    return GraphicsJNI::createBitmap(env, bitmap, false, NULL);

}



static int nativeGetHeight(JNIEnv* env, jobject, SkBitmapRegionDecoder *brd) {

    return brd->getHeight();

}



static int nativeGetWidth(JNIEnv* env, jobject, SkBitmapRegionDecoder *brd) {

    return brd->getWidth();

}



static void nativeClean(JNIEnv* env, jobject, SkBitmapRegionDecoder *brd) {

    delete brd;

}



///////////////////////////////////////////////////////////////////////////////



#include <android_runtime/AndroidRuntime.h>



static JNINativeMethod gBitmapRegionDecoderMethods[] = {

    {   "nativeDecodeRegion",

        "(IIIIILandroid/graphics/BitmapFactory$Options;)Landroid/graphics/Bitmap;",

        (void*)nativeDecodeRegion},



    {   "nativeGetHeight", "(I)I", (void*)nativeGetHeight},



    {   "nativeGetWidth", "(I)I", (void*)nativeGetWidth},



    {   "nativeClean", "(I)V", (void*)nativeClean},



    {   "nativeNewInstance",

        "([BIIZ)Landroid/graphics/BitmapRegionDecoder;",

        (void*)nativeNewInstanceFromByteArray

    },



    {   "nativeNewInstance",

        "(Ljava/io/InputStream;[BZ)Landroid/graphics/BitmapRegionDecoder;",

        (void*)nativeNewInstanceFromStream

    },



    {   "nativeNewInstance",

        "(Ljava/io/FileDescriptor;Z)Landroid/graphics/BitmapRegionDecoder;",

        (void*)nativeNewInstanceFromFileDescriptor

    },



    {   "nativeNewInstance",

        "(IZ)Landroid/graphics/BitmapRegionDecoder;",

        (void*)nativeNewInstanceFromAsset

    },

};



#define kClassPathName  "android/graphics/BitmapRegionDecoder"



int register_android_graphics_BitmapRegionDecoder(JNIEnv* env);

int register_android_graphics_BitmapRegionDecoder(JNIEnv* env)

{

    return android::AndroidRuntime::registerNativeMethods(env, kClassPathName,

            gBitmapRegionDecoderMethods, SK_ARRAY_COUNT(gBitmapRegionDecoderMethods));

}

core/jni/android/graphics/Graphics.cpp

+0 −24
Original line number Diff line number Diff line
@@ -168,9 +168,6 @@ static jmethodID gBitmap_allocBufferMethodID; 
static jclass   gBitmapConfig_class;

static jfieldID gBitmapConfig_nativeInstanceID;



static jclass   gBitmapRegionDecoder_class;

static jmethodID gBitmapRegionDecoder_constructorMethodID;



static jclass   gCanvas_class;

static jfieldID gCanvas_nativeInstanceID;
@@ -377,24 +374,6 @@ jobject GraphicsJNI::createBitmap(JNIEnv* env, SkBitmap* bitmap, bool isMutable, 
    return obj;

}



jobject GraphicsJNI::createBitmapRegionDecoder(JNIEnv* env, SkBitmapRegionDecoder* bitmap)

{

    SkASSERT(bitmap != NULL);



    jobject obj = env->AllocObject(gBitmapRegionDecoder_class);

    if (hasException(env)) {

        obj = NULL;

        return obj;

    }

    if (obj) {

        env->CallVoidMethod(obj, gBitmapRegionDecoder_constructorMethodID, (jint)bitmap);

        if (hasException(env)) {

            obj = NULL;

        }

    }

    return obj;

}



jobject GraphicsJNI::createRegion(JNIEnv* env, SkRegion* region)

{

    SkASSERT(region != NULL);
@@ -613,9 +592,6 @@ int register_android_graphics_Graphics(JNIEnv* env) 
    gBitmap_constructorMethodID = env->GetMethodID(gBitmap_class, "<init>",

                                            "(IZ[BI)V");



    gBitmapRegionDecoder_class = make_globalref(env, "android/graphics/BitmapRegionDecoder");

    gBitmapRegionDecoder_constructorMethodID = env->GetMethodID(gBitmapRegionDecoder_class, "<init>", "(I)V");



    gBitmapConfig_class = make_globalref(env, "android/graphics/Bitmap$Config");

    gBitmapConfig_nativeInstanceID = getFieldIDCheck(env, gBitmapConfig_class,

                                                     "nativeInt", "I");