Sérialisation et dé-sérialisation de android.graphics.Bitmap en Java

J'ai commencé à travailler sur ma première application android et les principes de base d'une application qui gère une image avec plusieurs couches. Je suis en mesure d'exporter une version plate du projet en tant que fichier de PNG, mais je voudrais être en mesure de sauver l'image superposée pour, plus tard, l'édition (y compris toutes les options appliquées à certaines couches, telles que le texte en fonction des couches).

De toute façon, j'ai veillé à ce que les classes qui doivent être écrites dans un fichier sont "Serializable", mais dans un peu d'un bloc de route causé par le fait que android.les graphiques.Bitmap n'est pas sérialisable. Le code suivant essentiellement les sorties de l'image Bitmap au format PNG dans un objet ByteArray et devraient le lire en tant que partie de la "readObject'. Toutefois, lorsque le code s'exécute - je peux vérifier que le "imageByteArrayLength' variable qui est lu est la même que celle qui est sortie mais la "Bitmap de l'image" est toujours null.

Toute aide serait grandement appréciée. Merci pour la lecture.

private String title;
private int width;
private int height;
private Bitmap sourceImage;
private Canvas sourceCanvas;        
private Bitmap currentImage;
private Canvas currentCanvas;   
private Paint currentPaint; 
private void writeObject(ObjectOutputStream out) throws IOException{
out.writeObject(title);
out.writeInt(width);
out.writeInt(height);
ByteArrayOutputStream stream = new ByteArrayOutputStream();
currentImage.compress(Bitmap.CompressFormat.PNG, 100, stream);
byte[] imageByteArray = stream.toByteArray();
int length = imageByteArray.length;
out.writeInt(length);
out.write(imageByteArray);          
}
private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException{
this.title = (String)in.readObject();
this.width = in.readInt();
this.height = in.readInt();
int imageByteArrayLength = in.readInt();
byte[] imageByteArray = new byte[imageByteArrayLength];
in.read(imageByteArray, 0, imageByteArrayLength);
BitmapFactory.Options opt = new BitmapFactory.Options();
opt.inPreferredConfig = Bitmap.Config.ARGB_8888;
Bitmap image = BitmapFactory.decodeByteArray(imageByteArray, 0, imageByteArrayLength, opt);
sourceImage = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888);
currentImage = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888);
sourceCanvas = new Canvas(sourceImage);
currentCanvas = new Canvas(currentImage);
currentPaint = new Paint(Paint.ANTI_ALIAS_FLAG);
if ( image != null ) {
sourceCanvas.drawBitmap(image, 0, 0, currentPaint);
}
}

source d'informationauteur John Wordsworth | 2011-05-03

  1. 25

    Il a fallu du temps, mais j'ai trouvé une solution propre à ce problème. J'ai produit un objet personnalisé (BitmapDataObject) qui implémente Serializable et a un byte[] pour stocker les PNG des données à partir de l'image d'origine. En utilisant cette option, les données sont correctement enregistrés dans le ObjectOutputStream /ObjectInputStream, qui permet de Sérialiser et Désérialiser un objet Bitmap en les stockant dans un PNG dans un byte[] dans un objet personnalisé. Le code ci-dessous résout ma requête.

    private String title;
private int sourceWidth, currentWidth;
private int sourceHeight, currentHeight;
private Bitmap sourceImage;
private Canvas sourceCanvas;        
private Bitmap currentImage;
private Canvas currentCanvas;   
private Paint currentPaint; 
protected class BitmapDataObject implements Serializable {
private static final long serialVersionUID = 111696345129311948L;
public byte[] imageByteArray;
}
/** Included for serialization - write this layer to the output stream. */
private void writeObject(ObjectOutputStream out) throws IOException{
out.writeObject(title);
out.writeInt(currentWidth);
out.writeInt(currentHeight);
ByteArrayOutputStream stream = new ByteArrayOutputStream();
currentImage.compress(Bitmap.CompressFormat.PNG, 100, stream);
BitmapDataObject bitmapDataObject = new BitmapDataObject();     
bitmapDataObject.imageByteArray = stream.toByteArray();
out.writeObject(bitmapDataObject);
}
/** Included for serialization - read this object from the supplied input stream. */
private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException{
title = (String)in.readObject();
sourceWidth = currentWidth = in.readInt();
sourceHeight = currentHeight = in.readInt();
BitmapDataObject bitmapDataObject = (BitmapDataObject)in.readObject();
Bitmap image = BitmapFactory.decodeByteArray(bitmapDataObject.imageByteArray, 0, bitmapDataObject.imageByteArray.length);
sourceImage = Bitmap.createBitmap(sourceWidth, sourceHeight, Bitmap.Config.ARGB_8888);
currentImage = Bitmap.createBitmap(sourceWidth, sourceHeight, Bitmap.Config.ARGB_8888);
sourceCanvas = new Canvas(sourceImage);
currentCanvas = new Canvas(currentImage);
currentPaint = new Paint(Paint.ANTI_ALIAS_FLAG);
thumbnailPaint = new Paint(Paint.ANTI_ALIAS_FLAG);
thumbnailPaint.setARGB(255, 200, 200, 200);
thumbnailPaint.setStyle(Paint.Style.FILL);
}
  2. 2

    Voici un exemple de sérialisation de l'objet qui peut envelopper les bitmaps. 

    public class BitmapDataObject implements Serializable {
private Bitmap currentImage;
public BitmapDataObject(Bitmap bitmap)
{
currentImage = bitmap;
}
private void writeObject(java.io.ObjectOutputStream out) throws IOException {
ByteArrayOutputStream stream = new ByteArrayOutputStream();
currentImage.compress(Bitmap.CompressFormat.PNG, 100, stream);
byte[] byteArray = stream.toByteArray();
out.writeInt(byteArray.length);
out.write(byteArray);
}
private void readObject(java.io.ObjectInputStream in) throws IOException, ClassNotFoundException {
int bufferLength = in.readInt();
byte[] byteArray = new byte[bufferLength];
int pos = 0;
do {
int read = in.read(byteArray, pos, bufferLength - pos);
if (read != -1) {
pos += read;
} else {
break;
}
} while (pos < bufferLength);
currentImage = BitmapFactory.decodeByteArray(byteArray, 0, bufferLength);
}
}