Android Bitmap do Base64 String

Question

Jak przekonwertować dużą bitmapę (zdjęcie zrobione aparatem telefonu) na ciąg Base64?

Answer 1

zastosowanie następująca metoda konwersji bitmapy do tablicy bajtów:

ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream(); 
bitmap.compress(Bitmap.CompressFormat.PNG, 100, byteArrayOutputStream); 
byte[] byteArray = byteArrayOutputStream .toByteArray(); 

do kodowania base64 z bajtów wykorzystania tablicy następujące metody

String encoded = Base64.encodeToString(byteArray, Base64.DEFAULT); 

Answer 2

Użyj getPixels, aby uzyskać bitmapę jako tablicę bajtów. Następnie możesz użyć kodowania Base64.encodeToString. To będzie działać tylko dla API poziomu 8 i większego. Zobacz pytanie o numer this dla starszych urządzeń.

Answer 3

Problem z odpowiedzią Jeet jest, aby załadować wszystkie bajty obraz do tablicy bajtowej, co prawdopodobnie spowoduje awarię aplikacji na urządzeniach low-end. Zamiast tego najpierw zapisałbym obraz do pliku i przeczytałam go przy użyciu klasy Apache o numerze Base64InputStream. Następnie możesz utworzyć ciąg Base64 bezpośrednio z InputStream tego pliku. Będzie to wyglądać tak:

//Don't forget the manifest permission to write files 
final FileOutputStream fos = new FileOutputStream(yourFileHere); 
bitmap.compress(Bitmap.CompressFormat.PNG, 100, fos); 

fos.close(); 

final InputStream is = new Base64InputStream(new FileInputStream(yourFileHere)); 

//Now that we have the InputStream, we can read it and put it into the String 
final StringWriter writer = new StringWriter(); 
IOUtils.copy(is , writer, encoding); 
final String yourBase64String = writer.toString(); 

Jak widać, powyższe rozwiązanie działa bezpośrednio z potoków zamiast, unikając konieczności załadowania wszystkie bajty do zmiennej, dlatego dzięki czemu zużycie pamięci znacznie niższe i mniej prawdopodobne awarie w urządzeniach low-end. Nadal jest problem z tym, że umieszczanie łańcucha Base64 w zmiennej String nie jest dobrym pomysłem, ponieważ może to spowodować błędy OutOfMemory. Ale przynajmniej zmniejszyliśmy zużycie pamięci o połowę, eliminując tablicę bajtów.

Jeśli chcesz pominąć krok zapisu do pliku, musisz przekonwertować OutputStream na InputStream, co nie jest tak proste do zrobienia (musisz użyć PipedInputStream, ale to jest trochę bardziej skomplikowane, ponieważ dwa strumienie muszą zawsze być w różnych wątkach).

Answer 4

Mam szybkie rozwiązanie. Wystarczy utworzyć plik ImageUtil.java

import android.graphics.Bitmap; 
import android.graphics.BitmapFactory; 
import android.util.Base64; 
import java.io.ByteArrayOutputStream; 

public class ImageUtil 
{ 
    public static Bitmap convert(String base64Str) throws IllegalArgumentException 
    { 
     byte[] decodedBytes = Base64.decode(
      base64Str.substring(base64Str.indexOf(",") + 1), 
      Base64.DEFAULT 
     ); 

     return BitmapFactory.decodeByteArray(decodedBytes, 0, decodedBytes.length); 
    } 

    public static String convert(Bitmap bitmap) 
    { 
     ByteArrayOutputStream outputStream = new ByteArrayOutputStream(); 
     bitmap.compress(Bitmap.CompressFormat.PNG, 100, outputStream); 

     return Base64.encodeToString(outputStream.toByteArray(), Base64.DEFAULT); 
    } 

} 

Zastosowanie:

Bitmap bitmap = ImageUtil.convert(base64String); 

lub

String base64String = ImageUtil.convert(bitmap); 

Answer 5

Spróbuj najpierw przeskalować obraz do wymaganej wysokości i szerokości, po prostu przekazać oryginalną bitmapę, wymagana szerokość i wymaganą wysokość dla poniższej metody i uzyskać skalowaną bitmapę w zamian:

Na przykład: Bitmap scaledBitmap = getScaledBitmap (originalBitmap, 250, 350);

private Bitmap getScaledBitmap(Bitmap b, int reqWidth, int reqHeight) 
{ 
    int bWidth = b.getWidth(); 
    int bHeight = b.getHeight(); 

    int nWidth = bWidth; 
    int nHeight = bHeight; 

    if(nWidth > reqWidth) 
    { 
     int ratio = bWidth/reqWidth; 
     if(ratio > 0) 
     { 
      nWidth = reqWidth; 
      nHeight = bHeight/ratio; 
     } 
    } 

    if(nHeight > reqHeight) 
    { 
     int ratio = bHeight/reqHeight; 
     if(ratio > 0) 
     { 
      nHeight = reqHeight; 
      nWidth = bWidth/ratio; 
     } 
    } 

    return Bitmap.createScaledBitmap(b, nWidth, nHeight, true); 
} 

Teraz wystarczy zdać skalowane bitmapy z następującą metodą base64 ciąg i dostać w zamian:

Na przykład: String base64String = getBase64String (scaledBitmap);

private String getBase64String(Bitmap bitmap) 
{ 
    ByteArrayOutputStream baos = new ByteArrayOutputStream(); 

    bitmap.compress(Bitmap.CompressFormat.JPEG, 100, baos); 

    byte[] imageBytes = baos.toByteArray(); 

    String base64String = Base64.encodeToString(imageBytes, Base64.NO_WRAP); 

    return base64String; 
} 

zdekodować ciąg base64 powrotem do bitmapy:

byte[] decodedByteArray = Base64.decode(base64String, Base64.NO_WRAP); 
Bitmap decodedBitmap = BitmapFactory.decodeByteArray(decodedByteArray, 0, decodedString.length);