Develop Reference

Android compress image with small size and good quality from camera intent

In my app user can take picture from camera intent , then I save this image as full size image
not thumbnail. Then what I want to do is use this saved image to compress it and send it over to server.
The image size from camera intent is around 7-8 MB and resolution of 5664x4248.
The requirements is to achieve is image of same size and quality of whatsapp which is 40-80KB
I tried different solution but I couldn't achieve the same good quality and size.
For this I used id.zelory:compressor:2.1.1 library
Any Idea?
Here I call this method after saving the image to resize it
private File customCompressImage (File imgFile) {
String destinationDirectoryPath= Environment.getExternalStorageDirectory().getPath() + "/Pictures/";
try {
return new CustomCompressor(context)
.setMaxWidth(612)
.setMaxHeight(816)
.setQuality(80)
.setCompressFormat(Bitmap.CompressFormat.JPEG)
.setDestinationDirectoryPath(destinationDirectoryPath)
.compressToFile(imgFile);
} catch (IOException e) {
e.printStackTrace();
}
return null;
}
CompressImage
static File compressImage(File imageFile, int reqWidth, int reqHeight, Bitmap.CompressFormat compressFormat, int quality, String destinationPath) throws IOException {
FileOutputStream fileOutputStream = null;
File file = new File(destinationPath).getParentFile();
if (!file.exists()) {
file.mkdirs();
}
try {
fileOutputStream = new FileOutputStream(destinationPath);
// write the compressed bitmap at the destination specified by destinationPath.
decodeSampledBitmapFromFile(imageFile, reqWidth, reqHeight).compress(compressFormat, quality, fileOutputStream);
} finally {
if (fileOutputStream != null) {
fileOutputStream.flush();
fileOutputStream.close();
}
}
return new File(destinationPath);
}
static Bitmap decodeSampledBitmapFromFile(File imageFile, int reqWidth, int reqHeight) throws IOException {
// First decode with inJustDecodeBounds=true to check dimensions
BitmapFactory.Options options = new BitmapFactory.Options();
options.inJustDecodeBounds = true;
BitmapFactory.decodeFile(imageFile.getAbsolutePath(), options);
// Calculate inSampleSize
options.inSampleSize = calculateInSampleSize(options, reqWidth, reqHeight);
// Decode bitmap with inSampleSize set
options.inJustDecodeBounds = false;
Bitmap scaledBitmap = BitmapFactory.decodeFile(imageFile.getAbsolutePath(), options);
//check the rotation of the image and display it properly
ExifInterface exif;
exif = new ExifInterface(imageFile.getAbsolutePath());
int orientation = exif.getAttributeInt(ExifInterface.TAG_ORIENTATION, 0);
Matrix matrix = new Matrix();
if (orientation == 6) {
matrix.postRotate(90);
} else if (orientation == 3) {
matrix.postRotate(180);
} else if (orientation == 8) {
matrix.postRotate(270);
}
scaledBitmap = Bitmap.createBitmap(scaledBitmap, 0, 0, scaledBitmap.getWidth(), scaledBitmap.getHeight(), matrix, true);
return scaledBitmap;
}
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) {
final int halfHeight = height / 2;
final int halfWidth = width / 2;
// Calculate the largest inSampleSize value that is a power of 2 and keeps both
// height and width larger than the requested height and width.
while ((halfHeight / inSampleSize) >= reqHeight && (halfWidth / inSampleSize) >= reqWidth) {
inSampleSize *= 2;
}
}
return inSampleSize;
}
I tried passing different max width and height and quality and I never achived both small size and good quality

You can try this piece of code.
public static Bitmap getCompressed( Bitmap imageBitmap) {
ByteArrayOutputStream bytes = new ByteArrayOutputStream();
imageBitmap.compress(Bitmap.CompressFormat.JPEG, 100, bytes);
return imageBitmap;
}
// 100 is quality,
change it according to your need

#End User shouldn't it be like this instead (that's at least what I get from reading the documentation):
public static Bitmap getCompressed(Bitmap imageBitmap) {
ByteArrayOutputStream out = new ByteArrayOutputStream();
if (!imageBitmap.compress(Bitmap.CompressFormat.JPEG, 100, out))
throw new IllegalStateException("Unable to compress image");
ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
return BitmapFactory.decodeStream(in);
}

Uri.getPath() is null

I'm trying to auto-rotate pictures from system gallery intent, but ExifInterface can't get the path from picture uri.
It's crashing on this line:
img
Creating gallery intent:
Intent intent = new Intent();
intent.setType("image/*");
intent.setAction(Intent.ACTION_GET_CONTENT);
startActivityForResult(Intent.createChooser(intent, getString(R.string.choose_image)), 1);
onActivityResult:
#Override
protected void onActivityResult(int RequestCode, int ResultCode, Intent I) {
super.onActivityResult(RequestCode, ResultCode, I);
if (RequestCode == 1 && ResultCode == RESULT_OK && I != null && I.getData() != null) {
uri = I.getData();
try {
ImageBitmap = handleSamplingAndRotationBitmap(Gallery.this, uri);
} catch (IOException e) {
e.printStackTrace();
}
SelectedImage.setImageBitmap(ImageBitmap);
detectImage();
} else {
Intent intent = new Intent(this, MainActivity.class);
startActivity(intent);
}
}
Rotating:
/**
* This method is responsible for solving the rotation issue if exist. Also scale the images to
* 1024x1024 resolution
*
* #param context The current context
* #param selectedImage The Image URI
* #return Bitmap image results
* #throws IOException
*/
public static Bitmap handleSamplingAndRotationBitmap(Context context, Uri selectedImage)
throws IOException {
int MAX_HEIGHT = 1024;
int MAX_WIDTH = 1024;
// 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);
img = rotateImageIfRequired(img, selectedImage);
return img;
}
/**
* Calculate an inSampleSize for use in a {#link BitmapFactory.Options} object when decoding
* bitmaps using the decode* methods from {#link BitmapFactory}. This implementation calculates
* the closest inSampleSize that will result in the final decoded bitmap having a width and
* height equal to or larger than the requested width and height. This implementation does not
* ensure a power of 2 is returned for inSampleSize which can be faster when decoding but
* results in a larger bitmap which isn't as useful for caching purposes.
*
* #param options An options object with out* params already populated (run through a decode*
* method with inJustDecodeBounds==true
* #param reqWidth The requested width of the resulting bitmap
* #param reqHeight The requested height of the resulting bitmap
* #return The value to be used for inSampleSize
*/
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;
}
/**
* Rotate an image if required.
*
* #param img The image bitmap
* #param selectedImage Image URI
* #return The resulted Bitmap after manipulation
*/
private static Bitmap rotateImageIfRequired(Bitmap img, Uri selectedImage) throws IOException {
ExifInterface ei = new ExifInterface(selectedImage.getPath());//HERE IS PROBLEM
int orientation = ei.getAttributeInt(ExifInterface.TAG_ORIENTATION, ExifInterface.ORIENTATION_NORMAL);
switch (orientation) {
case ExifInterface.ORIENTATION_ROTATE_90:
return rotateImage(img, 90);
case ExifInterface.ORIENTATION_ROTATE_180:
return rotateImage(img, 180);
case ExifInterface.ORIENTATION_ROTATE_270:
return rotateImage(img, 270);
default:
return img;
}
}
private static Bitmap rotateImage(Bitmap img, int degree) {
Matrix matrix = new Matrix();
matrix.postRotate(degree);
Bitmap rotatedImg = Bitmap.createBitmap(img, 0, 0, img.getWidth(), img.getHeight(), matrix, true);
img.recycle();
return rotatedImg;
}
This rotating was fully copied from another question, where it works. So i don`t know what is wrong. Uri have path inside, but getPath() can not find it...

Android hashmap clear onTrimMemory doesnot releases memory

I have a hashmap of Bitmap , which provides the adapterview with required thmbnails of images to show.
My thumbnail size is likely within 64x64 dp box.
But still i see logs like heap grown for alloction of 1.xx mb. Then i printed the bytecounts, and verified that the code i use doesn't do actually thumbnailing. The resulting bitmaps are of size mostly greater than megbytes.
The code i use is as below
#Override
protected Bitmap doInBackground(Uri... params) {
data = params[0];
// Log.e(TAG,"Async Task Drawable doInBackground");
try {
Bitmap bmp;
if (MainActivity.thumbCache.containsKey(albumId)) {
bmp = (Bitmap) MainActivity.thumbCache.get(albumId);
Log.e("BMWT-HM-Size","getting from Cache"+String.valueOf(MainActivity.thumbCache.size()));
Log.e(TAG,": bmp.getByteCount() "+bmp.getByteCount());
} else {
in = res.openInputStream(data);
songArtOptions.inJustDecodeBounds = true;
BitmapFactory.decodeStream(in,null,songArtOptions);
Log.e(TAG,String.valueOf(songArtOptions.outWidth)+"x"+String.valueOf(songArtOptions.outHeight)+": "+songArtOptions.outMimeType);
songArtOptions.inSampleSize = calculateInSampleSize(songArtOptions,songArtWidth,songArtHeight);
Log.e(TAG,"subSampleLevel = "+String.valueOf(songArtOptions.inSampleSize));
in = res.openInputStream(data);
songArtOptions.inJustDecodeBounds = false;
bmp = BitmapFactory.decodeStream(in,null,songArtOptions);
MainActivity.thumbCache.put(albumId, bmp);
Log.e("BMWT-HM-Size","newly decoded"+String.valueOf(MainActivity.thumbCache.size()));
Log.e(TAG,": bmp.getByteCount() "+bmp.getByteCount());
}
return bmp;
} catch (FileNotFoundException e) {
return defaultArt;
}
}
public static int calculateInSampleSize(
BitmapFactory.Options options, int reqWidth, int reqHeight) {
int inSampleSize = 1;
if (options.outHeight > reqHeight || options.outWidth > reqWidth) {
int halfHeight = options.outHeight >> 1;
int halfWidth = options.outWidth >> 1;
// Calculate the largest inSampleSize value that is a power of 2 and
// keeps both
// height and width larger than the requested height and width.
while (halfWidth > reqWidth && halfHeight > reqHeight) {
inSampleSize <<= 1;
halfWidth >>= 1;
halfHeight >>= 1;
}
}
return inSampleSize;
}
As a result, my heap grows as much images are put into the hashmap.
in OnTrimMemory I call, thumbCache.clear,which i hoped to release the occupied memory by the elements of hashmap, but it doesn't. The heap status stays the same.
How to clean this out. I want to maintain cache as long as the view is visible and want to clear the cache(which i mean releasing the occupied memory to be GC'ed) whne view is fully destroyed.

If you are sure the Bitmap has no further uses， you can call Bitmap.recycle() to reclaim memory after you remove it from your cache.

How to determine iglargest stable bitmap dimensions

I am working on an app that allows a user to draw within a confined canvas on a bitmap. Each drawing is created on a separate bitmap, which is then added to the main bitmap in the onDraw() method. This main bitmap needs to be larger than the screen dimensions so the user has plenty of room to draw a detailed scene. As such I also gave users the ability to pan/zoom on this main bitmap.
I noticed that this main bitmap size affects the performance of the device's drawing ability. The dimension have statically set at this point is 3000X3000, which works fine for my Galaxy 10.1 Pro tablet, but is VERY choppy on my low end Galaxy phone. This app is not meant to be used on phones, but the issue is still the same: how do I dynamically determine the dimensions for the main bitmap so that performance is consistent across devices?

If you want to see what the screen size is, do this. Docs here
Display display = getWindowManager().getDefaultDisplay();
Point size = new Point();
display.getSize(size);
int width = size.x;
int height = size.y;
Then you can use that information to resize the image.
You can set o.inJustDecodeBounds = true to get the image sizes without loading the image. If the image is to big, you can resize it. Example code below.
private Bitmap getBitmap(String path) {
Uri uri = getImageUri(path);
InputStream in = null;
try {
final int IMAGE_MAX_SIZE = 1200000; // 1.2MP
in = mContentResolver.openInputStream(uri);
// Decode image size
BitmapFactory.Options o = new BitmapFactory.Options();
o.inJustDecodeBounds = true;
BitmapFactory.decodeStream(in, null, o);
in.close();
int scale = 1;
while ((o.outWidth * o.outHeight) * (1 / Math.pow(scale, 2)) >
IMAGE_MAX_SIZE) {
scale++;
}
Log.d(TAG, "scale = " + scale + ", orig-width: " + o.outWidth + ",
orig-height: " + o.outHeight);
Bitmap b = null;
in = mContentResolver.openInputStream(uri);
if (scale > 1) {
scale--;
// scale to max possible inSampleSize that still yields an image
// larger than target
o = new BitmapFactory.Options();
o.inSampleSize = scale;
b = BitmapFactory.decodeStream(in, null, o);
// resize to desired dimensions
int height = b.getHeight();
int width = b.getWidth();
Log.d(TAG, "1th scale operation dimenions - width: " + width + ",
height: " + height);
double y = Math.sqrt(IMAGE_MAX_SIZE
/ (((double) width) / height));
double x = (y / height) * width;
Bitmap scaledBitmap = Bitmap.createScaledBitmap(b, (int) x,
(int) y, true);
b.recycle();
b = scaledBitmap;
System.gc();
} else {
b = BitmapFactory.decodeStream(in);
}
in.close();
Log.d(TAG, "bitmap size - width: " +b.getWidth() + ", height: " +
b.getHeight());
return b;
} catch (IOException e) {
Log.e(TAG, e.getMessage(),e);
return null;
}

Bitmap out of range error

I'm resizing an array of Bitmaps to a certain percentage of screen (So looks the same on all devices). Some of the bitmaps are sprites with + 256kb in size (explosions etc).
Obviously the VM is running out of memory once the bitmaps are converted twice, the bitmaps only convert at the beginning of the android application but it's still giving the error.
Can anyone tell me, is there a better, faster, more effcient way to return this peice of code as a bitmap.
Just out of curiosity are bitmap values passed by reference? (As in does the object parameter use the same line of memory for the same object?).
Anyhow's here is z code:
public Bitmap ResizeBitmap(Bitmap bitmap, float s_percentage, int frames, int viewport_width, int viewport_height)
{
float percentage = s_percentage / 100.0f;
float scale = viewport_width / 100 * percentage;
if(viewport_width < viewport_height)
{
scale = viewport_height / 100 * percentage;
}
int newWidth = (int) (bitmap.getWidth() * scale);
int newHeight = (int) (bitmap.getHeight() * scale);
if(newWidth <= 0 || newHeight <= 0)
{
// Extra check, for invalid width/height
Log.e("Function List, Resize Bitmap", "invalid dimension ("+newWidth+"x"+newHeight+")");
return bitmap;
}
//Round up to closet factor of total frames
int rW = (newWidth/frames)+1;
newWidth = rW*frames;
Bitmap newBitmap = Bitmap.createScaledBitmap(bitmap, newWidth, newHeight, false);
return newBitmap;
}

To be in VM budget try to scale down your Bitmap like this.
BitmapFactory.Options options = new BitmapFactory.Options();
options.inJustDecodeBounds = true;
BitmapFactory.decodeFile( filename, options );
options.inJustDecodeBounds = false;
options.inSampleSize = 4;
bitmap = BitmapFactory.decodeFile( filename, options );
if ( bitmap != null ) {
bitmap = Bitmap.createScaledBitmap( bitmap, width, height, false );
}
//Adjust SampleSize to values like 2, 4, 8 etc