"Jednak nie mam pojęcia, jak upewnić się, że bitmap pozostanie jako 32 bity przez cały proces."
Chciałem opublikować alternatywne rozwiązanie, które dba o utrzymanie konfiguracji ARGB_8888 nietkniętej. UWAGA: Ten kod dekoduje bitmapy i wymaga rozszerzenia, więc możesz zapisać bitmapę.
Zakładam, piszesz kod dla wersji Androida niższej niż 3.2 (poziom API < 12), ponieważ od tego czasu zachowanie metod
BitmapFactory.decodeFile(pathToImage);
BitmapFactory.decodeFile(pathToImage, opt);
bitmapObject.createScaledBitmap(bitmap, desiredWidth, desiredHeight, false /*filter?*/);
uległ zmianie.
Na starszych platformach (poziom API < 12) metody BitmapFactory.decodeFile (..) próbują domyślnie przywrócić bitmapę z konfiguracją RGB_565, jeśli nie mogą znaleźć żadnej alfa, co obniża jakość elementu iamge. Jest to nadal ok, bo można egzekwowanie bitmapę ARGB_8888 użyciu
options.inPrefferedConfig = Bitmap.Config.ARGB_8888
options.inDither = false
Prawdziwy problem pojawia się, gdy każdy piksel obrazu ma wartość alfa 255 (czyli całkowicie nieprzezroczysta). W takim przypadku flaga bitmap 'hasAlpha' jest ustawiona na false, nawet jeśli Twoja Bitmapa ma konfigurację ARGB_8888. Jeśli twój plik * .png miał co najmniej jeden prawdziwy przezroczysty piksel, ta flaga byłaby ustawiona na true i nie musiałbyś się o nic martwić.
Więc jeśli chcesz stworzyć skalowany bitmapę korzystając
bitmapObject.createScaledBitmap(bitmap, desiredWidth, desiredHeight, false /*filter?*/);
kontrole metod czy flagą „hasAlpha” jest ustawiona na wartość true lub false, aw twoim przypadku jest ona ustawiona na false, co powoduje uzyskanie skalowanej bitmapy, która została automatycznie przekonwertowana do formatu RGB_565.
Dlatego na poziomie API> = 12 istnieje metoda publiczna o nazwie
public void setHasAlpha (boolean hasAlpha);
które rozwiązały ten problem. Jak dotąd było to tylko wytłumaczenie problemu. Zrobiłem kilka badań i zauważyłem, że metoda setHasAlpha istnieje od dłuższego czasu i jest publiczna, ale została ukryta (@hide adnotacja). Oto, jak to jest zdefiniowane w systemie 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);
}
Oto moja propozycja rozwiązania. Nie pociąga za sobą żadnych kopiowaniu danych bitmapy:
sprawdzone w czasie wykonywania przy użyciu java.lang.reflect jeśli obecna implementacja bitmapy ma publiczną metodę „setHasAplha”. (Według moich testów działa idealnie od poziomu API 3 i nie testowałem niższych wersji, ponieważ JNI nie działałoby). Mogą wystąpić problemy, jeśli producent wyraźnie przyznał, że jest prywatny, chroniony lub usunięty.
Wywołanie metody "setHasAlpha" dla danego obiektu Bitmap za pomocą JNI. Działa to doskonale, nawet w przypadku prywatnych metod lub pól. Oficjalne jest, że JNI nie sprawdza, czy naruszasz zasady kontroli dostępu, czy też nie. Źródło: http://java.sun.com/docs/books/jni/html/pitfalls.html (10.9) Daje nam to ogromną moc, która powinna być używana mądrze. Nie próbowałbym modyfikować pola końcowego, nawet gdyby działało (wystarczy podać przykład). I proszę pamiętać, jest to tylko obejście ...
Oto moja wdrożenie wszystkich niezbędnych metod:
JAVA CZĘŚĆ:
// 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;
}
Załaduj lib i zadeklarować sposób natywny:
static {
System.loadLibrary("bitmaputils");
}
private static native int setHasAlphaNative(Bitmap bitmap, boolean value);
Język odcinek ('jni' folder)
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
}
To wszystko. Skończyliśmy. Wysłałem cały kod do kopiowania i wklejania. Rzeczywisty kod nie jest aż tak duży, ale sprawdzenie wszystkich paranoicznych błędów sprawia, że jest on o wiele większy. Mam nadzieję, że może to być przydatne dla każdego.
Czy zmieniasz rozmiar obrazów, aby rozwiązać problemy z różnymi gęstościami ekranu? Jeśli tak, domyślam się, że uruchamiasz ten kod przy pierwszym uruchomieniu, a nie po kolejnych uruchomieniach ... Czy po prostu uruchamiasz go lokalnie, aby uzyskać nowe zasoby (czyli obrazy) dla małych ekranów? Jestem ciekawy, ponieważ mam błędy na ekranach o małej gęstości. – gary
W moim przypadku nie chodzi tu o gęstość ekranu. Po prostu próbuję dopasować dany zestaw obrazów do pewnego pojemnika. – cottonBallPaws