Android - Lesen PNG-Bild ohne alpha-und entschlüsseln als ARGB_8888

Einer ARGB_8888 Bitmap - (für pre-Honeycomb-Versionen) ist systemintern gespeichert in das RGBA-format.
So ist der alpha-Kanal bewegt am Ende. Sie sollten dies berücksichtigen, wenn der Zugriff auf ein Bitmap-Pixel nativ.

Ich nehme an, Sie sind das schreiben von code für eine Android-version niedriger als 3.2 (API level < 12), weil da ist dann das Verhalten der Methoden

BitmapFactory.decodeFile(pathToImage);
BitmapFactory.decodeFile(pathToImage, opt);
bitmapObject.createScaledBitmap(bitmap, desiredWidth, desiredHeight, false /*filter?*/);

geändert hat.

Auf älteren Plattformen (API level < 12) der BitmapFactory.decodeFile (..) - Methoden versuchen, wieder eine Bitmap mit RGB_565 config standardmäßig, wenn Sie nicht finden können alle alpha, das senkt die Qualität der bildreihen. Ist das noch ok, da kann man die Durchsetzung von ARGB_8888 bitmap mit

options.inPrefferedConfig = Bitmap.Config.ARGB_8888
options.inDither = false 

Das eigentliche problem kommt, wenn jedes pixel des Bildes hat einen alpha-Wert von 255 (d.h. vollständig deckend). In diesem Fall wird das Bitmap-flag 'hasAlpha' auf false gesetzt ist, auch wenn Ihr Bitmap hat ARGB_8888 config. Wenn Ihr *.png-Datei hatte wenigstens eine echte transparente pixel, dieses flag auf true festgelegt wurde, und Sie nicht haben, um nichts zu kümmern.

Also, wenn Sie wollen, erstellen Sie eine Bitmap skaliert mit

bitmapObject.createScaledBitmap(bitmap, desiredWidth, desiredHeight, false /*filter?*/);

die Methode überprüft, ob die 'hasAlpha' - flag ist auf true oder false gesetzt, und in Ihrem Fall ist es auf false gesetzt, werden die Ergebnisse bei der Erlangung einer skalierten Bitmap, die automatisch konvertiert die RGB_565 format.

Daher auf API-Ebene >= 12 es gibt eine öffentliche Methode namens

public void setHasAlpha (boolean hasAlpha);

hätte dieses Problem gelöst. Bisher war dies nur eine Erklärung für das problem.
Ich habe einige nachforschungen und festgestellt, dass die setHasAlpha Methode hat für eine lange Zeit bestanden, und es ist öffentlich, aber versteckt wurde (@hide annotation). Hier ist, wie es definiert ist, auf Android 2.3:

/**
 * Tell the bitmap if all of the pixels are known to be opaque (false)
 * or if some of the pixels may contain non-opaque alpha values (true).
 * Note, for some configs (e.g. RGB_565) this call is ignore, since it does
 * not support per-pixel alpha values.
 *
 * This is meant as a drawing hint, as in some cases a bitmap that is known
 * to be opaque can take a faster drawing case than one that may have
 * non-opaque per-pixel alpha values.
 *
 * @hide
 */
public void setHasAlpha(boolean hasAlpha) {
    nativeSetHasAlpha(mNativeBitmap, hasAlpha);
}

Hier ist nun mein Lösungsvorschlag. Sie ist nicht mit dem kopieren der bitmap-Daten:

1. Überprüft zur Laufzeit mit java.lang.Widerspiegeln, wenn der aktuelle
   Bitmap-Implementierung hat eine öffentliche "setHasAplha' - Methode.
   (Nach meinen tests funktioniert es einwandfrei seit API-level 3 und habe ich noch nicht getestet niedrigeren Versionen, weil JNI nicht funktionieren würde). Sie haben möglicherweise Probleme, wenn ein Hersteller explizit gemacht, es als privat, geschützt oder gelöscht.

2. Nennen sich die "setHasAlpha' Methode für eine gegebene Bitmap-Objekt mittels JNI.
   Das funktioniert perfekt, auch für private Methoden oder Felder. Nun ist es offiziell, dass JNI nicht prüfen, ob Sie gegen die access-control-Regeln oder nicht.
   Quelle: http://java.sun.com/docs/books/jni/html/pitfalls.html (10.9)
   Das gibt uns große Kraft, die sollten sinnvoll genutzt werden. Ich würde nicht versuchen, ändern eine Letzte Feld, selbst wenn es funktionieren würde (nur um ein Beispiel zu geben). Und bitte beachten: dies ist nur ein workaround...

Hier ist meine Umsetzung aller erforderlichen Methoden:

JAVA-TEIL:

//NOTE: this cannot be used in switch statements
    private static final boolean SETHASALPHA_EXISTS = setHasAlphaExists();

    private static boolean setHasAlphaExists() {
        //get all puplic Methods of the class Bitmap
        java.lang.reflect.Method[] methods = Bitmap.class.getMethods();
        //search for a method called 'setHasAlpha'
        for(int i=0; i<methods.length; i++) {
            if(methods[i].getName().contains("setHasAlpha")) {
                Log.i(TAG, "method setHasAlpha was found");
                return true;
            }
        }
        Log.i(TAG, "couldn't find method setHasAlpha");
        return false;
    }

    private static void setHasAlpha(Bitmap bitmap, boolean value) {
        if(bitmap.hasAlpha() == value) {
            Log.i(TAG, "bitmap.hasAlpha() == value -> do nothing");
            return;
        }

        if(!SETHASALPHA_EXISTS) {   //if we can't find it then API level MUST be lower than 12
            //couldn't find the setHasAlpha-method
            //<-- provide alternative here...
            return;
        }

        //using android.os.Build.VERSION.SDK to support API level 3 and above
        //use android.os.Build.VERSION.SDK_INT to support API level 4 and above
        if(Integer.valueOf(android.os.Build.VERSION.SDK) <= 11) {
            Log.i(TAG, "BEFORE: bitmap.hasAlpha() == " + bitmap.hasAlpha());
            Log.i(TAG, "trying to set hasAplha to true");
            int result = setHasAlphaNative(bitmap, value);
            Log.i(TAG, "AFTER: bitmap.hasAlpha() == " + bitmap.hasAlpha());

            if(result == -1) {
                Log.e(TAG, "Unable to access bitmap."); //usually due to a bug in the own code
                return;
            }
        } else {    //API level >= 12
            bitmap.setHasAlpha(true);
        }
    }

    /**
     * Decodes a Bitmap from the SD card
     * and scales it if necessary
     */
    public Bitmap decodeBitmapFromFile(String pathToImage, int pixels_limit) {
        Bitmap bitmap;

        Options opt = new Options();
        opt.inDither = false;   //important
        opt.inPreferredConfig = Bitmap.Config.ARGB_8888;
        bitmap = BitmapFactory.decodeFile(pathToImage, opt);

        if(bitmap == null) {
            Log.e(TAG, "unable to decode bitmap");
            return null;
        }

        setHasAlpha(bitmap, true);  //if necessary

        int numOfPixels = bitmap.getWidth() * bitmap.getHeight();

        if(numOfPixels > pixels_limit) {    //image needs to be scaled down 
            //ensures that the scaled image uses the maximum of the pixel_limit while keeping the original aspect ratio
            //i use: private static final int pixels_limit = 1280*960; //1,3 Megapixel
            imageScaleFactor = Math.sqrt((double) pixels_limit / (double) numOfPixels);
            Bitmap scaledBitmap = Bitmap.createScaledBitmap(bitmap,
                    (int) (imageScaleFactor * bitmap.getWidth()), (int) (imageScaleFactor * bitmap.getHeight()), false);

            bitmap.recycle();
            bitmap = scaledBitmap;

            Log.i(TAG, "scaled bitmap config: " + bitmap.getConfig().toString());
            Log.i(TAG, "pixels_limit = " + pixels_limit);
            Log.i(TAG, "scaled_numOfpixels = " + scaledBitmap.getWidth()*scaledBitmap.getHeight());

            setHasAlpha(bitmap, true); //if necessary
        }

        return bitmap;
    }

Laden Sie Ihre lib und deklariert die native Methode:

static {
    System.loadLibrary("bitmaputils");
}

private static native int setHasAlphaNative(Bitmap bitmap, boolean value);

Nativen Abschnitt ('jni' Ordner)

Android.mk:

LOCAL_PATH := $(call my-dir)

include $(CLEAR_VARS)
LOCAL_MODULE    := bitmaputils
LOCAL_SRC_FILES := bitmap_utils.c
LOCAL_LDLIBS := -llog -ljnigraphics -lz -ldl -lgcc
include $(BUILD_SHARED_LIBRARY)

bitmapUtils.c:

#include <jni.h>
#include <android/bitmap.h>
#include <android/log.h>

#define  LOG_TAG    "BitmapTest"
#define  Log_i(...)  __android_log_print(ANDROID_LOG_INFO,LOG_TAG,__VA_ARGS__)
#define  Log_e(...)  __android_log_print(ANDROID_LOG_ERROR,LOG_TAG,__VA_ARGS__)


//caching class and method IDs for a faster subsequent access
static jclass bitmap_class = 0;
static jmethodID setHasAlphaMethodID = 0;

jint Java_com_example_bitmaptest_MainActivity_setHasAlphaNative(JNIEnv * env, jclass clazz, jobject bitmap, jboolean value) {
    AndroidBitmapInfo info;
    void* pixels;


    if (AndroidBitmap_getInfo(env, bitmap, &info) < 0) {
        Log_e("Failed to get Bitmap info");
        return -1;
    }

    if (info.format != ANDROID_BITMAP_FORMAT_RGBA_8888) {
        Log_e("Incompatible Bitmap format");
        return -1;
    }

    if (AndroidBitmap_lockPixels(env, bitmap, &pixels) < 0) {
        Log_e("Failed to lock the pixels of the Bitmap");
        return -1;
    }


    //get class
    if(bitmap_class == NULL) {  //initializing jclass
        //NOTE: The class Bitmap exists since API level 1, so it just must be found.
        bitmap_class = (*env)->GetObjectClass(env, bitmap);
        if(bitmap_class == NULL) {
            Log_e("bitmap_class == NULL");
            return -2;
        }
    }

    //get methodID
    if(setHasAlphaMethodID == NULL) { //initializing jmethodID
        //NOTE: If this fails, because the method could not be found the App will crash.
        //But we only call this part of the code if the method was found using java.lang.Reflect
        setHasAlphaMethodID = (*env)->GetMethodID(env, bitmap_class, "setHasAlpha", "(Z)V");
        if(setHasAlphaMethodID == NULL) {
            Log_e("methodID == NULL");
            return -2;
        }
    }

    //call java instance method
    (*env)->CallVoidMethod(env, bitmap, setHasAlphaMethodID, value);

    //if an exception was thrown we could handle it here
    if ((*env)->ExceptionOccurred(env)) {
        (*env)->ExceptionDescribe(env);
        (*env)->ExceptionClear(env);
        Log_e("calling setHasAlpha threw an exception");
        return -2;
    }

    if(AndroidBitmap_unlockPixels(env, bitmap) < 0) {
        Log_e("Failed to unlock the pixels of the Bitmap");
        return -1;
    }

    return 0;   //success
}

Das ist es. Wir sind fertig. Ich habe den gesamten code für copy-and-paste-Zwecke.
Der eigentliche code ist nicht groß, aber alle diese paranoid Fehler überprüft, macht es viel größer ist. Ich hoffe, dass dies hilfreich sein könnte für jedermann.