Почему метод Bitmap.decodeFile() возвращает ноль?

Question

Я пытаюсь декодировать файл в растровое изображение, как это -

 BitmapFactory.Options options = new BitmapFactory.Options();
    try {
        Bitmap bitmap = BitmapFactory.decodeFile(mCurrentPhotoPath, options);
        cropImageView.setImageBitmap(bitmap);
        Log.d("Musik","bitmap - "+bitmap+" "+mCurrentPhotoPath);
    }
    catch (Exception e){
        Log.d("Musik",e.toString());
    }

и мой mCurrentPhotoPath

file:/storage/sdcard0/Android/data/com.example.iaugmentor.iaugmentortestvers/files/Pictures/JPEG_20160805_161105_478260200.jpg

Я не могу найти, почему он возвращает значение NULL, а также исключение не пойман.

Пожалуйста помоги. Заранее спасибо.

Чтобы прояснить ситуацию, позвольте мне указать, как я сохраняю изображение. Сначала я создаю объект File, а затем записываю изображение и сохраняю его в заданном Uri.

// Create the File where the photo should go
                    File photoFile = null;
                    try {
                        photoFile = createImageFile();
                    } catch (IOException ex) {
                        // Error occurred while creating the File

                    }

                    if (items[which].equals("Take Photo")) {

                        Intent intent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);

                        if(intent.resolveActivity(getPackageManager()) != null) {


                            // Continue only if the File was successfully created
                            if (photoFile != null) {
                                profilePicUri = FileProvider.getUriForFile(ApplicationContext.getAppContext(),
                                        "com.example.iaugmentor.iaugmentortestvers",
                                        photoFile);


                            }
                            intent.putExtra(android.provider.MediaStore.EXTRA_OUTPUT, profilePicUri);

                            try {
                                intent.putExtra("return-data", true);

                                startActivityForResult(intent, RESULT_LOAD_IMG);
                            } catch (ActivityNotFoundException e) {
                                e.printStackTrace();
                            }
                        }

Метод createImageFile() работает следующим образом

private File createImageFile() throws IOException {
    // Create an image file name
    String timeStamp = new SimpleDateFormat("yyyyMMdd_HHmmss").format(new Date());
    String imageFileName = "JPEG_" + timeStamp + "_";
    File storageDir = getExternalFilesDir(Environment.DIRECTORY_PICTURES);
    File image = File.createTempFile(
            imageFileName,  /* prefix */
            ".jpg",         /* suffix */
            storageDir      /* directory */
    );

    // Save a file: path for use with ACTION_VIEW intents
    mCurrentPhotoPath = "file:" + image.getAbsolutePath();
    return image;
}

Затем я пытаюсь прочитать изображение из другой деятельности с помощью переменной mCurrentPhotoPath

Answer 1

Создать / сохранить файл Path: mCurrentPhotoPath как это в вашем методе createImageFile().

File imageFile = new File(image.getAbsolutePath()); 

mCurrentPhotoPath = imageFile.toString();

Answer 2

bitmap = BitmapFactory.decodeFile(capturedImageFilePath);

ИЛИ ЖЕ

private static String filename;
public static Bitmap compressImage(String imageUri,Context mContext) {

    String filePath = getRealPathFromURI(imageUri,mContext);
    Bitmap scaledBitmap = null;

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

    // by setting this field as true, the actual bitmap pixels are not
    // loaded in the memory. Just the bounds are loaded. If
    // you try the use the bitmap here, you will get null.
    options.inJustDecodeBounds = true;
    Bitmap bmp = BitmapFactory.decodeFile(filePath, options);

    int actualHeight = options.outHeight;
    int actualWidth = options.outWidth;

    // max Height and width values of the compressed image is taken as
    // 816x612

    float maxHeight = 816.0f;
    float maxWidth = 612.0f;
    float imgRatio = actualWidth / actualHeight;
    float maxRatio = maxWidth / maxHeight;

    // width and height values are set maintaining the aspect ratio of the
    // image

    if (actualHeight > maxHeight || actualWidth > maxWidth) {
        if (imgRatio < maxRatio) {
            imgRatio = maxHeight / actualHeight;
            actualWidth = (int) (imgRatio * actualWidth);
            actualHeight = (int) maxHeight;
        } else if (imgRatio > maxRatio) {
            imgRatio = maxWidth / actualWidth;
            actualHeight = (int) (imgRatio * actualHeight);
            actualWidth = (int) maxWidth;
        } else {
            actualHeight = (int) maxHeight;
            actualWidth = (int) maxWidth;

        }
    }

    // setting inSampleSize value allows to load a scaled down version of
    // the original image

    options.inSampleSize = calculateInSampleSize(options, actualWidth,
            actualHeight);

    // inJustDecodeBounds set to false to load the actual bitmap
    options.inJustDecodeBounds = false;

    // this options allow android to claim the bitmap memory if it runs low
    // on memory
    options.inPurgeable = true;
    options.inInputShareable = true;
    options.inTempStorage = new byte[16 * 1024];

    try {
        // load the bitmap from its path
        bmp = BitmapFactory.decodeFile(filePath, options);
    } catch (OutOfMemoryError exception) {
        exception.printStackTrace();

    }
    try {
        scaledBitmap = Bitmap.createBitmap(actualWidth, actualHeight,
                Bitmap.Config.ARGB_8888);
    } catch (OutOfMemoryError exception) {
        exception.printStackTrace();
    }

    float ratioX = actualWidth / (float) options.outWidth;
    float ratioY = actualHeight / (float) options.outHeight;
    float middleX = actualWidth / 2.0f;
    float middleY = actualHeight / 2.0f;

    Matrix scaleMatrix = new Matrix();
    scaleMatrix.setScale(ratioX, ratioY, middleX, middleY);

    Canvas canvas = new Canvas(scaledBitmap);
    canvas.setMatrix(scaleMatrix);
    canvas.drawBitmap(bmp, middleX - bmp.getWidth() / 2,
            middleY - bmp.getHeight() / 2, new Paint(
                    Paint.FILTER_BITMAP_FLAG));

    // check the rotation of the image and display it properly
    ExifInterface exif;
    try {
        exif = new ExifInterface(filePath);

        int orientation = exif.getAttributeInt(
                ExifInterface.TAG_ORIENTATION, 0);
        Log.d("EXIF", "Exif: " + orientation);
        Matrix matrix = new Matrix();
        if (orientation == 6) {
            matrix.postRotate(90);
            Log.d("EXIF", "Exif: " + orientation);
        } else if (orientation == 3) {
            matrix.postRotate(180);
            Log.d("EXIF", "Exif: " + orientation);
        } else if (orientation == 8) {
            matrix.postRotate(270);
            Log.d("EXIF", "Exif: " + orientation);
        }
        scaledBitmap = Bitmap.createBitmap(scaledBitmap, 0, 0,
                scaledBitmap.getWidth(), scaledBitmap.getHeight(), matrix,
                true);
    } catch (IOException e) {
        e.printStackTrace();
    }

    FileOutputStream out = null;
    filename = getFilename();
    try {
        out = new FileOutputStream(filename);

        // write the compressed bitmap at the destination specified by
        // filename.
        //scaledBitmap.compress(Bitmap.CompressFormat.JPEG, 80, out);
        if(filePath.contains(".png") || filePath.contains(".PNG")){
            scaledBitmap.compress(Bitmap.CompressFormat.PNG, 100, out);
        }else{
            scaledBitmap.compress(Bitmap.CompressFormat.JPEG, 100, out);    
        }
        // ContentValues values = new ContentValues();
        //
        // values.put(Images.Media.DATE_TAKEN,
        // System.currentTimeMillis());
        // values.put(Images.Media.MIME_TYPE, "image/jpeg");
        // values.put(MediaStore.MediaColumns.DATA,filename);
        //
        // ((Activity)mContext).getContentResolver().insert(
        // Images.Media.EXTERNAL_CONTENT_URI, values);

    } catch (FileNotFoundException e) {
        e.printStackTrace();
    }

    return new BitmapFactory().decodeFile(filename);

}

public String getCompressedBitmapFilePath() {
    return filename;
}