BitmapFactory.decodeStream restituisce null quando le opzioni sono impostate

Question

Ho problemi con BitmapFactory.decodeStream(inputStream). Quando lo si utilizza senza opzioni, restituirà un'immagine. Ma quando lo uso con le opzioni come in .decodeStream(inputStream, null, options) non restituisce mai le bitmap.

Quello che sto cercando di fare è di ridimensionare un bitmap prima di caricarlo effettivamente per risparmiare memoria. Ho letto alcune buone guide, ma nessuna utilizza .decodeStream.

• Handling large Bitmaps

• And here

• Image Processing in Android

funziona bene

URL url = new URL(sUrl); 
HttpURLConnection connection = (HttpURLConnection) url.openConnection(); 

InputStream is = connection.getInputStream(); 
Bitmap img = BitmapFactory.decodeStream(is, null, options); 

non funziona

InputStream is = connection.getInputStream(); 
Bitmap img = BitmapFactory.decodeStream(is, null, options); 

InputStream is = connection.getInputStream(); 

Options options = new BitmapFactory.Options(); 
options.inJustDecodeBounds = true; 

BitmapFactory.decodeStream(is, null, options); 

Boolean scaleByHeight = Math.abs(options.outHeight - TARGET_HEIGHT) >= Math.abs(options.outWidth - TARGET_WIDTH); 

if (options.outHeight * options.outWidth * 2 >= 200*100*2){ 
    // Load, scaling to smallest power of 2 that'll get it <= desired dimensions 
    double sampleSize = scaleByHeight 
    ? options.outHeight/TARGET_HEIGHT 
    : options.outWidth/TARGET_WIDTH; 
    options.inSampleSize = 
     (int)Math.pow(2d, Math.floor(
     Math.log(sampleSize)/Math.log(2d))); 
} 

// Do the actual decoding 
options.inJustDecodeBounds = false; 
Bitmap img = BitmapFactory.decodeStream(is, null, options); 

Answer 1

Il problema era che una volta utilizzato un InputStream da un HttpUrlConnection per recuperare i metadati dell'immagine, non è possibile riavvolgere e utilizzare di nuovo lo stesso InputStream.

Pertanto è necessario creare un nuovo InputStream per il campionamento effettivo dell'immagine.

Options options = new BitmapFactory.Options(); 
    options.inJustDecodeBounds = true; 

    BitmapFactory.decodeStream(is, null, options); 

    Boolean scaleByHeight = Math.abs(options.outHeight - TARGET_HEIGHT) >= Math.abs(options.outWidth - TARGET_WIDTH); 

    if(options.outHeight * options.outWidth * 2 >= 200*200*2){ 
     // Load, scaling to smallest power of 2 that'll get it <= desired dimensions 
     double sampleSize = scaleByHeight 
       ? options.outHeight/TARGET_HEIGHT 
       : options.outWidth/TARGET_WIDTH; 
     options.inSampleSize = 
       (int)Math.pow(2d, Math.floor(
       Math.log(sampleSize)/Math.log(2d))); 
    } 

     // Do the actual decoding 
     options.inJustDecodeBounds = false; 

     is.close(); 
     is = getHTTPConnectionInputStream(sUrl); 
     Bitmap img = BitmapFactory.decodeStream(is, null, options); 
     is.close(); 

Answer 2

Credo che il problema è con la logica "calcolare scala-factor", perché resto del codice sembra corretto a me (assumendo, naturalmente, che InputStream non è nullo).

Sarebbe meglio se si potesse calcolare tutta la logica di calcolo delle dimensioni da questa routine in un metodo (chiamarlo calculateScaleFactor() o qualsiasi altra cosa) e testare prima questo metodo in modo indipendente.

Qualcosa di simile:

// Get the stream 
InputStream is = mUrl.openStream(); 

// get the Image bounds 
BitmapFactory.Options options=new BitmapFactory.Options(); 
options.inJustDecodeBounds = true; 

bitmap = BitmapFactory.decodeStream(is,null,options); 

//get actual width x height of the image and calculate the scale factor 
options.inSampleSize = getScaleFactor(options.outWidth,options.outHeight, 
       view.getWidth(),view.getHeight()); 

options.inJustDecodeBounds = false; 
bitmap=BitmapFactory.decodeStream(mUrl.openStream(),null,options); 

e prova getScaleFactor (...) in modo indipendente.

Aiuterà anche a circondare l'intero codice con il blocco try..catch {}, se non è già stato fatto.

Answer 3

Provare a capo InputStream con BufferedInputStream.

InputStream is = new BufferedInputStream(conn.getInputStream()); 
is.mark(is.available()); 
// Do the bound decoding 
// inJustDecodeBounds =true 
is.reset(); 
// Do the actual decoding 

Answer 4

È possibile convertire InputStream in un array di byte e utilizzare decodeByteArray(). Ad esempio,

public static Bitmap decodeSampledBitmapFromStream(InputStream inputStream, int reqWidth, int reqHeight) { 
    ByteArrayOutputStream outputStream = new ByteArrayOutputStream(); 
    try { 
     int n; 
     byte[] buffer = new byte[1024]; 
     while ((n = inputStream.read(buffer)) > 0) { 
      outputStream.write(buffer, 0, n); 
     } 
     return decodeSampledBitmapFromByteArray(outputStream.toByteArray(), reqWidth, reqHeight); 
    } catch (IOException e) { 
     e.printStackTrace(); 
    } finally { 
     try { 
      outputStream.close(); 
     } catch (IOException e) { 
      e.printStackTrace(); 
     } 
    } 
    return null; 
} 

public static Bitmap decodeSampledBitmapFromByteArray(byte[] data, int reqWidth, int reqHeight) { 
    BitmapFactory.Options options = new BitmapFactory.Options(); 
    options.inJustDecodeBounds = true; 
    BitmapFactory.decodeByteArray(data, 0, data.length, options); 
    options.inSampleSize = calculateInSampleSize(options, reqWidth, reqHeight); 
    options.inJustDecodeBounds = false; 
    return BitmapFactory.decodeByteArray(data, 0, data.length, options); 
} 

private static int calculateInSampleSize(BitmapFactory.Options options, int reqWidth, int 
     reqHeight) { 
    int width = options.outWidth; 
    int height = options.outHeight; 
    int inSampleSize = 1; 
    if (width > reqWidth || height > reqHeight) { 
     int halfWidth = width/2; 
     int halfHeight = height/2; 
     while (halfWidth/inSampleSize >= reqWidth && halfHeight/inSampleSize >= reqHeight) { 
      inSampleSize *= 2; 
     } 
    } 
    return inSampleSize; 
}