Réduire la taille de capture d'image de la caméra android

mPhoto.compress(Bitmap.CompressFormat.PNG, 100, bytes);

100, c'est le meilleur de la qualité. Si tu veux réduire la taille, puis essayez de decrase que la valeur

Autre façon peut-être d'utiliser inSampleSize paramètres de BitmapFactory.Options(). Cela devrait permettre de réduire la taille de trop. Vous pouvez lire buter que ici

edit:
Code

BitmapFactory.Options options = new BitmapFactory.Options();
options.inSampleSize=2; //4, 8, etc. the more value, the worst quality of image

Bitmap bmp=BitmapFactory.decodeStream(getContentResolver().openInputStream(CheckInGallery.mUri), null, options);

Qui devrait charger une image avec peu de moins bonne qualité.

puis enregistrer l'image

bmp.compress(Bitmap.CompressFormat.PNG, 70, bytes);

OriginalL'auteur Gooziec

**Reduce captured image size and save ..in kb**
String imagePath = context.getFilesDir().getAbsolutePath() + File.separatorChar + "FolderName" + File.separatorChar + "ImageFolder" + File.separatorChar + imageName + ".jpg";
File prescImagefile = new File(imagePath);
try
{
if (prescImagefile.exists() == false)
{
prescImagefile.getParentFile().mkdirs();
prescImagefile.createNewFile();
}
}
catch (IOException e)
{
//Log.e("TAG", "Could not create file.", e);
}
if (prescImagefile != null)
{
mCapturedImageURI = Uri.fromFile(prescImagefile);
if (mCapturedImageURI != null)
{
Intent cameraIntent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
cameraIntent.putExtra(MediaStore.EXTRA_OUTPUT, mCapturedImageURI);
startActivityForResult(cameraIntent, CAMERA_REQUEST);
}
}
@Override
public void onActivityResult(int requestCode, int resultCode, Intent data)
{
if (resultCode == RESULT_OK)
{
if (requestCode == CAMERA_REQUEST)
{
try
{
String path = mCapturedImageURI.getPath();
StoreImage(context, mCapturedImageURI, prescImagefile);
}
catch (Exception e)
{
e.printStackTrace();
}
}
}
}
public static void StoreImage(Context mContext, Uri imgUri, File imageDir)
{
Bitmap bm = null;
try
{
BitmapFactory.Options options = new BitmapFactory.Options();
options.inSampleSize = 2;
//bm = Media.getBitmap(mContext.getContentResolver(), imageLoc);
bm = BitmapFactory.decodeStream(mContext.getContentResolver().openInputStream(imgUri), null, options);
FileOutputStream out = new FileOutputStream(imageDir);
bm.compress(Bitmap.CompressFormat.JPEG, 20, out);
bm.recycle();
}
catch (Exception e)
{
e.printStackTrace();
}
}

OriginalL'auteur amy

C'est ce qui a fonctionné pour moi.

    public void onImageSelected(){
Uri uri=null; //get the uri of the image result from the intent
try {
Bitmap bitmap = handleSamplingAndRotationBitmap(this, uri);
byte[] bytes = getBytesFromBitmap(bitmap);
//getPresenter.upload(bytes);
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* returns an aligned bitmap with size not exceeding the MAX_HEIGHT
* @param context
* @param selectedImage
* @return
* @throws IOException
*/
public Bitmap handleSamplingAndRotationBitmap(Context context, Uri selectedImage)
throws IOException {
Bitmap decoded = getImageSampleOutput(context,selectedImage);
decoded = rotateImageIfRequired(this, decoded, selectedImage);
return decoded;
}
public Bitmap getImageSampleOutput(Context context, Uri selectedImage) throws IOException {
int MAX_HEIGHT = 1200;
int MAX_WIDTH = 1600;
//First decode with inJustDecodeBounds=true to check dimensions
final BitmapFactory.Options options = new BitmapFactory.Options();
options.inJustDecodeBounds = true;
InputStream imageStream = context.getContentResolver().openInputStream(selectedImage);
BitmapFactory.decodeStream(imageStream, null, options);
imageStream.close();
//Calculate inSampleSize
options.inSampleSize = calculateInSampleSize(options, MAX_WIDTH, MAX_HEIGHT);
//Decode bitmap with inSampleSize set
options.inJustDecodeBounds = false;
imageStream = context.getContentResolver().openInputStream(selectedImage);
Bitmap img = BitmapFactory.decodeStream(imageStream, null, options);
Bitmap decoded = compressImage(img);
return decoded;
}
/**
* Used to compress the image to prevent any Memory overflows.
* @param bitmap
* @return
*/
public Bitmap compressImage(Bitmap bitmap) {
ByteArrayOutputStream out = new ByteArrayOutputStream();
bitmap.compress(Bitmap.CompressFormat.JPEG, 100, out);
return BitmapFactory.decodeStream(new ByteArrayInputStream(out.toByteArray()));
}
private static int calculateInSampleSize(BitmapFactory.Options options,
int reqWidth, int reqHeight) {
//Raw height and width of image
final int height = options.outHeight;
final int width = options.outWidth;
int inSampleSize = 1;
if (height > reqHeight || width > reqWidth) {
//Calculate ratios of height and width to requested height and width
final int heightRatio = Math.round((float) height / (float) reqHeight);
final int widthRatio = Math.round((float) width / (float) reqWidth);
//Choose the smallest ratio as inSampleSize value, this will guarantee a final image
//with both dimensions larger than or equal to the requested height and width.
inSampleSize = heightRatio < widthRatio ? heightRatio : widthRatio;
//This offers some additional logic in case the image has a strange
//aspect ratio. For example, a panorama may have a much larger
//width than height. In these cases the total pixels might still
//end up being too large to fit comfortably in memory, so we should
//be more aggressive with sample down the image (=larger inSampleSize).
final float totalPixels = width * height;
//Anything more than 2x the requested pixels we'll sample down further
final float totalReqPixelsCap = reqWidth * reqHeight * 2;
while (totalPixels / (inSampleSize * inSampleSize) > totalReqPixelsCap) {
inSampleSize++;
}
}
return inSampleSize;
}
private static Bitmap rotateImageIfRequired(Context context, Bitmap img, Uri selectedImage) {
//Detect rotation
int rotation = getRotation(context, selectedImage);
if (rotation != 0) {
Matrix matrix = new Matrix();
matrix.postRotate(rotation);
Bitmap rotatedImg = Bitmap.createBitmap(img, 0, 0, img.getWidth(), img.getHeight(), matrix, true);
img.recycle();
return rotatedImg;
} else {
return img;
}
}
/**
* Get the rotation of the last image added.
*
* @param context
* @param selectedImage
* @return
*/
private static int getRotation(Context context, Uri selectedImage) {
int rotation = 0;
ContentResolver content = context.getContentResolver();
Cursor mediaCursor = content.query(MediaStore.Images.Media.EXTERNAL_CONTENT_URI,
new String[]{"orientation", "date_added"},
null, null, "date_added desc");
if (mediaCursor != null && mediaCursor.getCount() != 0) {
while (mediaCursor.moveToNext()) {
rotation = mediaCursor.getInt(0);
break;
}
}
mediaCursor.close();
return rotation;
}
public byte[] getBytesFromBitmap(Bitmap bmp){
ByteArrayOutputStream stream = new ByteArrayOutputStream();
bmp.compress(Bitmap.CompressFormat.JPEG,70,stream);
byte[] byteArray = stream.toByteArray();
return byteArray;
}

Sur un Samusung Galaxy S7, j'ai été en mesure de réduire la taille jusqu'à 300 ko.

OriginalL'auteur Irshu