Android - BitmapFactory.decodeStream null zurück auf Samsung-Geräten

Question

Diese Linie auf Samsung A5 und Samsung Junge versagt, und arbeitet an HTC, Motorola, Sony usw.

ich das gleiche IMAGE getestet habe, aber ich anders Ergebnisse.

Der Wert von decodedBitmap ist immer null auf Samsung, und ich kann nicht herausfinden, warum.

In dem Bild unten können Sie überprüfen, was der aktuelle Wert von decoderingOptions ist. Ich habe versucht, keine Optionen zu verwenden, aber ich bekomme das gleiche Ergebnis.

Dies ist der Code, Im mit. Wie Sie sehen können, verwende ich Universal Image Load und Debugging Ich habe dieses Problem gefunden.

/******************************************************************************* 
* Copyright 2011-2014 Sergey Tarasevich 
* 
* Licensed under the Apache License, Version 2.0 (the "License"); 
* you may not use this file except in compliance with the License. 
* You may obtain a copy of the License at 
* 
* http://www.apache.org/licenses/LICENSE-2.0 
* 
* Unless required by applicable law or agreed to in writing, software 
* distributed under the License is distributed on an "AS IS" BASIS, 
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
* See the License for the specific language governing permissions and 
* limitations under the License. 
*******************************************************************************/ 
package com.nostra13.universalimageloader.core.decode; 

import android.graphics.Bitmap; 
import android.graphics.BitmapFactory; 
import android.graphics.BitmapFactory.Options; 
import android.graphics.Matrix; 
import android.media.ExifInterface; 
import com.nostra13.universalimageloader.core.assist.ImageScaleType; 
import com.nostra13.universalimageloader.core.assist.ImageSize; 
import com.nostra13.universalimageloader.core.download.ImageDownloader.Scheme; 
import com.nostra13.universalimageloader.utils.ImageSizeUtils; 
import com.nostra13.universalimageloader.utils.IoUtils; 
import com.nostra13.universalimageloader.utils.L; 

import java.io.IOException; 
import java.io.InputStream; 

/** 
* Decodes images to {@link Bitmap}, scales them to needed size 
* 
* @author Sergey Tarasevich (nostra13[at]gmail[dot]com) 
* @see ImageDecodingInfo 
* @since 1.8.3 
*/ 
public class BaseImageDecoder implements ImageDecoder { 

    protected static final String LOG_SUBSAMPLE_IMAGE = "Subsample original image (%1$s) to %2$s (scale = %3$d) [%4$s]"; 
    protected static final String LOG_SCALE_IMAGE = "Scale subsampled image (%1$s) to %2$s (scale = %3$.5f) [%4$s]"; 
    protected static final String LOG_ROTATE_IMAGE = "Rotate image on %1$d\u00B0 [%2$s]"; 
    protected static final String LOG_FLIP_IMAGE = "Flip image horizontally [%s]"; 
    protected static final String ERROR_NO_IMAGE_STREAM = "No stream for image [%s]"; 
    protected static final String ERROR_CANT_DECODE_IMAGE = "Image can't be decoded [%s]"; 

    protected final boolean loggingEnabled; 

    /** 
    * @param loggingEnabled Whether debug logs will be written to LogCat. Usually should match {@link 
    *      com.nostra13.universalimageloader.core.ImageLoaderConfiguration.Builder#writeDebugLogs() 
    *      ImageLoaderConfiguration.writeDebugLogs()} 
    */ 
    public BaseImageDecoder(boolean loggingEnabled) { 
     this.loggingEnabled = loggingEnabled; 
    } 

    /** 
    * Decodes image from URI into {@link Bitmap}. Image is scaled close to incoming {@linkplain ImageSize target size} 
    * during decoding (depend on incoming parameters). 
    * 
    * @param decodingInfo Needed data for decoding image 
    * @return Decoded bitmap 
    * @throws IOException     if some I/O exception occurs during image reading 
    * @throws UnsupportedOperationException if image URI has unsupported scheme(protocol) 
    */ 
    @Override 
    public Bitmap decode(ImageDecodingInfo decodingInfo) throws IOException { 
     Bitmap decodedBitmap; 
     ImageFileInfo imageInfo; 

     InputStream imageStream = getImageStream(decodingInfo); 
     if (imageStream == null) { 
      L.e(ERROR_NO_IMAGE_STREAM, decodingInfo.getImageKey()); 
      return null; 
     } 
     try { 
      imageInfo = defineImageSizeAndRotation(imageStream, decodingInfo); 
      imageStream = resetStream(imageStream, decodingInfo); 
      Options decodingOptions = prepareDecodingOptions(imageInfo.imageSize, decodingInfo); 
      //================FAIL HERE============ 
      decodedBitmap = BitmapFactory.decodeStream(imageStream, null, decodingOptions); 
     } finally { 
      IoUtils.closeSilently(imageStream); 
     } 

     if (decodedBitmap == null) { 
      L.e(ERROR_CANT_DECODE_IMAGE, decodingInfo.getImageKey()); 
     } else { 
      decodedBitmap = considerExactScaleAndOrientatiton(decodedBitmap, decodingInfo, imageInfo.exif.rotation, 
        imageInfo.exif.flipHorizontal); 
     } 
     return decodedBitmap; 
    } 

    protected InputStream getImageStream(ImageDecodingInfo decodingInfo) throws IOException { 
     return decodingInfo.getDownloader().getStream(decodingInfo.getImageUri(), decodingInfo.getExtraForDownloader()); 
    } 

    protected ImageFileInfo defineImageSizeAndRotation(InputStream imageStream, ImageDecodingInfo decodingInfo) 
      throws IOException { 
     Options options = new Options(); 
     options.inJustDecodeBounds = true; 
     BitmapFactory.decodeStream(imageStream, null, options); 

     ExifInfo exif; 
     String imageUri = decodingInfo.getImageUri(); 
     if (decodingInfo.shouldConsiderExifParams() && canDefineExifParams(imageUri, options.outMimeType)) { 
      exif = defineExifOrientation(imageUri); 
     } else { 
      exif = new ExifInfo(); 
     } 
     return new ImageFileInfo(new ImageSize(options.outWidth, options.outHeight, exif.rotation), exif); 
    } 

    private boolean canDefineExifParams(String imageUri, String mimeType) { 
     return "image/jpeg".equalsIgnoreCase(mimeType) && (Scheme.ofUri(imageUri) == Scheme.FILE); 
    } 

    protected ExifInfo defineExifOrientation(String imageUri) { 
     int rotation = 0; 
     boolean flip = false; 
     try { 
      ExifInterface exif = new ExifInterface(Scheme.FILE.crop(imageUri)); 
      int exifOrientation = exif.getAttributeInt(ExifInterface.TAG_ORIENTATION, ExifInterface.ORIENTATION_NORMAL); 
      switch (exifOrientation) { 
       case ExifInterface.ORIENTATION_FLIP_HORIZONTAL: 
        flip = true; 
       case ExifInterface.ORIENTATION_NORMAL: 
        rotation = 0; 
        break; 
       case ExifInterface.ORIENTATION_TRANSVERSE: 
        flip = true; 
       case ExifInterface.ORIENTATION_ROTATE_90: 
        rotation = 90; 
        break; 
       case ExifInterface.ORIENTATION_FLIP_VERTICAL: 
        flip = true; 
       case ExifInterface.ORIENTATION_ROTATE_180: 
        rotation = 180; 
        break; 
       case ExifInterface.ORIENTATION_TRANSPOSE: 
        flip = true; 
       case ExifInterface.ORIENTATION_ROTATE_270: 
        rotation = 270; 
        break; 
      } 
     } catch (IOException e) { 
      L.w("Can't read EXIF tags from file [%s]", imageUri); 
     } 
     return new ExifInfo(rotation, flip); 
    } 

    protected Options prepareDecodingOptions(ImageSize imageSize, ImageDecodingInfo decodingInfo) { 
     ImageScaleType scaleType = decodingInfo.getImageScaleType(); 
     int scale; 
     if (scaleType == ImageScaleType.NONE) { 
      scale = 1; 
     } else if (scaleType == ImageScaleType.NONE_SAFE) { 
      scale = ImageSizeUtils.computeMinImageSampleSize(imageSize); 
     } else { 
      ImageSize targetSize = decodingInfo.getTargetSize(); 
      boolean powerOf2 = scaleType == ImageScaleType.IN_SAMPLE_POWER_OF_2; 
      scale = ImageSizeUtils.computeImageSampleSize(imageSize, targetSize, decodingInfo.getViewScaleType(), powerOf2); 
     } 
     if (scale > 1 && loggingEnabled) { 
      L.d(LOG_SUBSAMPLE_IMAGE, imageSize, imageSize.scaleDown(scale), scale, decodingInfo.getImageKey()); 
     } 

     Options decodingOptions = decodingInfo.getDecodingOptions(); 
     decodingOptions.inSampleSize = scale; 
     return decodingOptions; 
    } 

    protected InputStream resetStream(InputStream imageStream, ImageDecodingInfo decodingInfo) throws IOException { 
     if (imageStream.markSupported()) { 
      try { 
       imageStream.reset(); 
       return imageStream; 
      } catch (IOException ignored) { 
      } 
     } 
     IoUtils.closeSilently(imageStream); 
     return getImageStream(decodingInfo); 
    } 

    protected Bitmap considerExactScaleAndOrientatiton(Bitmap subsampledBitmap, ImageDecodingInfo decodingInfo, 
      int rotation, boolean flipHorizontal) { 
     Matrix m = new Matrix(); 
     // Scale to exact size if need 
     ImageScaleType scaleType = decodingInfo.getImageScaleType(); 
     if (scaleType == ImageScaleType.EXACTLY || scaleType == ImageScaleType.EXACTLY_STRETCHED) { 
      ImageSize srcSize = new ImageSize(subsampledBitmap.getWidth(), subsampledBitmap.getHeight(), rotation); 
      float scale = ImageSizeUtils.computeImageScale(srcSize, decodingInfo.getTargetSize(), decodingInfo 
        .getViewScaleType(), scaleType == ImageScaleType.EXACTLY_STRETCHED); 
      if (Float.compare(scale, 1f) != 0) { 
       m.setScale(scale, scale); 

       if (loggingEnabled) { 
        L.d(LOG_SCALE_IMAGE, srcSize, srcSize.scale(scale), scale, decodingInfo.getImageKey()); 
       } 
      } 
     } 
     // Flip bitmap if need 
     if (flipHorizontal) { 
      m.postScale(-1, 1); 

      if (loggingEnabled) L.d(LOG_FLIP_IMAGE, decodingInfo.getImageKey()); 
     } 
     // Rotate bitmap if need 
     if (rotation != 0) { 
      m.postRotate(rotation); 

      if (loggingEnabled) L.d(LOG_ROTATE_IMAGE, rotation, decodingInfo.getImageKey()); 
     } 

     Bitmap finalBitmap = Bitmap.createBitmap(subsampledBitmap, 0, 0, subsampledBitmap.getWidth(), subsampledBitmap 
       .getHeight(), m, true); 
     if (finalBitmap != subsampledBitmap) { 
      subsampledBitmap.recycle(); 
     } 
     return finalBitmap; 
    } 

    protected static class ExifInfo { 

     public final int rotation; 
     public final boolean flipHorizontal; 

     protected ExifInfo() { 
      this.rotation = 0; 
      this.flipHorizontal = false; 
     } 

     protected ExifInfo(int rotation, boolean flipHorizontal) { 
      this.rotation = rotation; 
      this.flipHorizontal = flipHorizontal; 
     } 
    } 

    protected static class ImageFileInfo { 

     public final ImageSize imageSize; 
     public final ExifInfo exif; 

     protected ImageFileInfo(ImageSize imageSize, ExifInfo exif) { 
      this.imageSize = imageSize; 
      this.exif = exif; 
     } 
    } 
} 

Answer 1

Nach Spezifikation decodeStream möglicherweise Null zurückgeben, wenn nicht dekodieren kann. Schauen Sie sich Quellen an, es gibt mehrere Fälle, in denen es wahr ist. Auch die Decodierung erfolgt im nativen Code. Es kommt also auf den Anbieter an.

bearbeiten

Sie können versuchen, aus dem Eingangsstrom zu Byte-Array zu lesen und es anstelle von Strom dekodieren. In diesem Fall zeigt es Ihnen, wo ein Problem ist: beim Lesen von Dateien oder beim Decodieren.

Auch Sie konnten Protokolle für einige hilfreiche Informationen wie fehlende Berechtigungen und so weiter lesen.