URI Location to save a photo

Question

How to create URI Location to save a photo captured by a camera?

I created a intent to start camera to captured photo. I want to pass URI location through the EXTRA_OUTP

Answer 1

Use this code for generate and call that file into camera intent

    File imagefile = null;
    try {
        imagefile = createImageFile();
    } catch (IOException ex) {
        // Error while creating the File
        Log.i(TAG, "IOException");
    }

    if (imagefile != null) {
        cameraIntent.putExtra(MediaStore.EXTRA_OUTPUT, Uri.fromFile(photoFile));
        startActivityForResult(cameraIntent, REQUEST_IMAGE_CAPTURE);
    }

here is code of generate Imagefile

private File createImageFile() throws IOException {

    String imageFileName = "JPEG_" + System.currentTimeMillis() + "_";
    File storageDir = Environment.getExternalStoragePublicDirectory(
            Environment.DIRECTORY_PICTURES);
    File image = File.createTempFile(
            imageFileName,  // prefix
            ".jpg",         // suffix
            storageDir      // directory
    );
    return image;
}

Answer 2

private void SaveImage(Bitmap finalBitmap) {

String root = Environment.getExternalStorageDirectory().toString();
File myDir = new File(root + "/saved_images");    
myDir.mkdirs();
Random generator = new Random();
int n = 10000;
n = generator.nextInt(n);
String fname = "Image-"+ n +".jpg";
File file = new File (myDir, fname);
if (file.exists ()) file.delete (); 
try {
       FileOutputStream out = new FileOutputStream(file);
       finalBitmap.compress(Bitmap.CompressFormat.JPEG, 90, out);
       out.flush();
       out.close();

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

}

Answer 3

I created PictureUtils class for capture image from camera and Gallery. Here is below code

PictureUtils.java

public class PictureUtils {

    private static String fileName;
    public Activity activity;

    public PictureUtils(Activity activity){
        this.activity = activity;
    }

    public Uri openCameraIntent(int requestCode) {
        Uri file = null;
        Intent intent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
            file = FileProvider.getUriForFile(activity, BuildConfig.APPLICATION_ID + ".provider", getOutputMediaFile());
        } else {
            file = Uri.fromFile(getOutputMediaFile());
        }

        intent.putExtra(MediaStore.EXTRA_OUTPUT, file);
        activity.startActivityForResult(intent, requestCode);

        return file;
    }

    public void openGalleryIntent(int requestCode) {
        Intent pickPhoto = new Intent(Intent.ACTION_PICK,
                MediaStore.Images.Media.EXTERNAL_CONTENT_URI);
        pickPhoto.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION);
        activity.startActivityForResult(pickPhoto, requestCode);
    }

    private static File getOutputMediaFile() {

        File mediaStorageDir = new File(Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_PICTURES) + "/RVRB");

        if (!mediaStorageDir.exists()) {
            if (!mediaStorageDir.mkdirs()) {
                return null;
            }
        }
        String timeStamp = String.valueOf(System.currentTimeMillis());
        fileName = timeStamp + ".jpg";

        return new File(mediaStorageDir.getAbsolutePath() + File.separator + fileName);
    }

    public ImagesData resultFromCamera(Intent data) {

        File imageFile = null;
        float rotationDegree = 0;
        String exifOrientation;
        ExifInterface exif = null;

        Bitmap rotatedBitmap = null;

        File storageDir = new File(Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_PICTURES) + "/RVRB");
        boolean success = true;
        if (!storageDir.exists()) {
            success = storageDir.mkdirs();
        }
        if (success) {
            imageFile = new File(storageDir, fileName);
        }

        try {
            exif = new ExifInterface(imageFile.getAbsolutePath());
            exifOrientation = exif.getAttribute(ExifInterface.TAG_ORIENTATION);

            if (Integer.parseInt(exifOrientation) >= 0 && Integer.parseInt(exifOrientation) <= 1) {
                rotationDegree = 0;
            } else if (Integer.parseInt(exifOrientation) >= 2 && Integer.parseInt(exifOrientation) <= 4) {
                rotationDegree = 180;
            } else if (Integer.parseInt(exifOrientation) >= 7 && Integer.parseInt(exifOrientation) >= 8) {
                rotationDegree = 270;
            } else {
                rotationDegree = 90;
            }

        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) {
            Bitmap thumbnail = null;
            if (data != null && data.getData() != null) {
                try {
                    thumbnail = MediaStore.Images.Media.getBitmap(activity.getContentResolver(), data.getData());
                    Matrix matrix = new Matrix();
                    matrix.postRotate(rotationDegree);
                    Bitmap scaledBitmap = Bitmap.createScaledBitmap(thumbnail, thumbnail.getWidth(), thumbnail.getHeight(), true);
                    rotatedBitmap = Bitmap.createBitmap(scaledBitmap, 0, 0, scaledBitmap.getWidth(), scaledBitmap.getHeight(), matrix, true);

                    if (imageFile != null) {
                        OutputStream fOut = new FileOutputStream(imageFile);
                        rotatedBitmap.compress(Bitmap.CompressFormat.JPEG, 70, fOut);
                        fOut.close();
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            } else {
                try {

                    thumbnail = MediaStore.Images.Media.getBitmap(activity.getContentResolver(), Uri.fromFile(imageFile));

                    Matrix matrix = new Matrix();
                    matrix.postRotate(rotationDegree);
                    Bitmap scaledBitmap = Bitmap.createScaledBitmap(thumbnail, thumbnail.getWidth(), thumbnail.getHeight(), true);
                    rotatedBitmap = Bitmap.createBitmap(scaledBitmap, 0, 0, scaledBitmap.getWidth(), scaledBitmap.getHeight(), matrix, true);

                    if (imageFile != null) {
                        OutputStream fOut = new FileOutputStream(imageFile);
                        rotatedBitmap.compress(Bitmap.CompressFormat.JPEG, 70, fOut);
                        fOut.close();
                    }

                } catch (IOException e) {
                    e.printStackTrace();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        } else {
            try {
                Bitmap bitmap = null;
                imageFile = new File(storageDir, fileName);

                bitmap = MediaStore.Images.Media.getBitmap(activity.getContentResolver(), Uri.fromFile(imageFile));

                if (bitmap != null && (bitmap.getHeight() < bitmap.getWidth())) {
                    Matrix matrix = new Matrix();
                    matrix.postRotate(rotationDegree);
                    Bitmap scaledBitmap = Bitmap.createScaledBitmap(bitmap, bitmap.getWidth(), bitmap.getHeight(), true);
                    rotatedBitmap = Bitmap.createBitmap(scaledBitmap, 0, 0, scaledBitmap.getWidth(), scaledBitmap.getHeight(), matrix, true);

                    if (imageFile != null) {
                        OutputStream fOut = new FileOutputStream(imageFile);
                        rotatedBitmap.compress(Bitmap.CompressFormat.JPEG, 70, fOut);
                        fOut.close();
                    }
                } else {
                    rotatedBitmap = bitmap;
                }

            } catch (IOException e) {
                e.printStackTrace();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }

        return new ImagesData(imageFile, rotatedBitmap);
    }

    public ImagesData imageFromGallery(Intent data) {

        File imageFile = null;
        float rotationDegree = 0;
        Bitmap rotatedBitmap = null;
        try {
            Bitmap bm = null;
            Uri selectedImage = null;
            if (data != null && data.getData() != null) {
                try {
                    selectedImage = data.getData();
                    bm = MediaStore.Images.Media.getBitmap(activity.getContentResolver(), selectedImage);

                } catch (IOException e) {
                    e.printStackTrace();
                }
            } else {
                try {
                    bm = (Bitmap) data.getExtras().get("data");
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }

            String timeStamp = String.valueOf(System.currentTimeMillis());
            String fileName = timeStamp + ".jpg";

            File storageDir = new File(Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_PICTURES) + "/RVRB");
            boolean success = true;
            if (!storageDir.exists()) {
                success = storageDir.mkdirs();
            }
            if (success) {
                imageFile = new File(storageDir, fileName);
            }

            rotationDegree = getRotationFromURI(selectedImage, activity);

            Matrix matrix = new Matrix();
            matrix.postRotate(rotationDegree);
            Bitmap scaledBitmap = Bitmap.createScaledBitmap(bm, bm.getWidth(), bm.getHeight(), true);
            rotatedBitmap = Bitmap.createBitmap(scaledBitmap, 0, 0, scaledBitmap.getWidth(), scaledBitmap.getHeight(), matrix, true);

            if (imageFile != null) {
                OutputStream fOut = new FileOutputStream(imageFile);
                rotatedBitmap.compress(Bitmap.CompressFormat.JPEG, 70, fOut);
                fOut.close();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return new ImagesData(imageFile, rotatedBitmap);
    }

    private int getRotationFromURI(Uri contentUri, Context mContext) {
        Cursor cursor = null;
        try {
            String[] proj = new String[]{MediaStore.Images.ImageColumns.ORIENTATION};
            cursor = mContext.getContentResolver().query(contentUri, proj, null, null, null);
            assert cursor != null;
            cursor.moveToFirst();
            return cursor.getInt(0);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (cursor != null) {
                cursor.close();
            }
        }
        return 0;
    }

    public class ImagesData {

        File imageFile = null;
        Bitmap bitmap = null;

        private ImagesData(File imageFile, Bitmap bitmap) {
            this.imageFile = imageFile;
            this.bitmap = bitmap;
        }

        public File getImageFile() {
            return imageFile;
        }

        public void setImageFile(File imageFile) {
            this.imageFile = imageFile;
        }

        public Bitmap getBitmap() {
            return bitmap;
        }

        public void setBitmap(Bitmap bitmap) {
            this.bitmap = bitmap;
        }
    }
}

Now you can call camera intent using below way on click of any button.

Global Declaration : Uri fileUri;

PictureUtils images = new PictureUtils(ArtistAddEditMembers.this);
fileUri = images.openCameraIntent(REQUEST_OPEN_CAMERA);

You can handel the result in onActivityResult method using below way.

@Override
    public void onActivityResult(int requestCode, int resultCode, Intent data) {
        super.onActivityResult(requestCode, resultCode, data);

        if (resultCode == Activity.RESULT_OK) {
            if (requestCode == REQUEST_OPEN_CAMERA) {
                try {
                    PictureUtils images = new PictureUtils(ArtistAddEditMembers.this);
                    PictureUtils.ImagesData imagesData = images.resultFromCamera(data);

                    imageFile = imagesData.getImageFile();
                    finalBitmap = imagesData.getBitmap();

                    displayImagePreview(finalBitmap);

                } catch (Exception e) {
                    e.printStackTrace();
                }
            } else if (requestCode == REQUEST_OPEN_GALLERY) {
                try {

                    PictureUtils images = new PictureUtils(ArtistAddEditMembers.this);
                    PictureUtils.ImagesData imagesData = images.imageFromGallery(data);

                    imageFile = imagesData.getImageFile();
                    finalBitmap = imagesData.getBitmap();

                    displayImagePreview(finalBitmap);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    }

For Display image in imageview

public void displayImagePreview(Bitmap bitmap) {
        Glide.with(mContext).load(bitmap).into(ivUserProfile);
    }

or you can simply set image bitmap in imageview without using glide.

I handeled below case in above example.

• If version is >= N, the I am using FileProvider.getUriForFile and Uri.fromFile for lower version.
• Display right rotation of Image instead of Display image after rotate.

Add below code in AndroidManefest.xml file under application tag for file provider

<application
......>

<provider
            android:name="android.support.v4.content.FileProvider"
            android:authorities="${applicationId}.provider"
            android:exported="false"
            android:grantUriPermissions="true">
            <meta-data
                android:name="android.support.FILE_PROVIDER_PATHS"
                android:resource="@xml/filepaths" />
        </provider>
</application>

Create filepaths.xml file under xml resource directory

<?xml version="1.0" encoding="utf-8"?>
<paths>
    <external-path name="external_files" path="."/>
</paths>

Make sure you popup and handel runtime permission for Camera and Write Internal Storage permission before call camera intent.