Develop Reference

What is difference between MemoryCacheSize and BitmapPoolSize in Glide

I'm curious about MemorySizeCalculator of Glide. I can get default memory cache size from getMemoryCacheSize() and bitmap pool size from getBitmapPoolSize().
MemorySizeCalculator:
/**
* Returns the recommended memory cache size for the device it is run on in bytes.
*/
public int getMemoryCacheSize() {
return memoryCacheSize;
}
/**
* Returns the recommended bitmap pool size for the device it is run on in bytes.
*/
public int getBitmapPoolSize() {
return bitmapPoolSize;
}
I understood memory cache concept as well but not sure bitmap pool size, so I found some information from this link : https://medium.com/#ali.muzaffar/performance-improvement-and-bitmap-pooling-in-android-f97b380cf965
Bitmap pooling is a simple technique (though fairly complex to
implement), that aims to reuse bitmaps instead of creating new ones
every time. To put it simply, when you need a bitmap, you check a
bitmap stack to see if there are any bitmaps available. If there are
not bitmaps available you create a new bitmap otherwise you pop a
bitmap from the stack and reuse it. Then when you are done with the
bitmap, you can put it on a stack.
I think that the bitmap which is pushed to a stack is also cached on memory. Is there anyone who can help me understand this concept?

bitmap pool cached dirty bitmap, that used to save time to create
bitmap. because we can't promise all of bitmap cached in
memoryCache.
memoryCache cached bitmap which you have used before.

Image heavy applications have to decode many images, so there will be continuous allocation and deallocation of memory in application. This results in frequent calling of the Garbage Collector (GC). And if you call the GC too many times, your application UI freezes. Glide use the Bitmap Pool Concept to load images efficiently. By using the Bitmap pool to avoid continuous allocation and deallocation of memory in your application, you reduce GC overhead, which results in a smooth-running application.
The basic principe is simple. When processing bitmap you have to verify if bitmap 2 is the same as bitmap 1. For this, you have to compare them. If it is the case you can reuse bitmap 1 as an inbitmap to reuse the same memory space to process gitmap 2 then skiping GC.
Memory cache is a memory space allocated to each application. One application cannot access the cache memory of other application.. It's size is limited.

Bitmap Size Exceed VM budget In android

In my android app i have set the image on ImageView capture by camera. its working fine. but when i capture image and back to the screen with setting that image on imageview and if i do this 3 to 4 time i got This ERROR BITMAP SIZE EXCEEDS VM BUDGETS ...................please need any solution for it.
this is my code below :
BitmapFactory.Options options = new BitmapFactory.Options();
options.inSampleSize = 4;
options.inTempStorage = new byte[16 * 1024];
image_from_camera.setImageBitmap(BitmapFactory.decodeFile(
"/sdcard/"+chore_string+".jpg", options));
i have done using bitmap.recycle(); or System.gc();
but this is not working . i need to have free the memory from bitmap when again camera button click to take second picture in app. PLEASE NEED ANY HELP........
THANKS. ...

increasing the value of the inSampleSize will decrease the memory overhead required to load the image. Change it to 8,12 or 16... and the image should eventually load but it might not look very good.
However, it seems like you might be using a good bit of memory prior to the load.
Use System.getRuntime() to get the runtime and then see what your max memory, total memory and free memory are to better understand how much space you have.
It's possible you are leaking memory prior to this allocation.
http://developer.android.com/reference/java/lang/Runtime.html
also (annoyingly) if you are using a device that can't run android 3.0 not all of the memory used will show up in the runtime calls. consider using a 3.0 device to more fully understand the memory usage.

Android Bitmap freeing memory - none of this works

I get "bitmap size exceeds VM budget", eventually with my app. So I added all of these things to help alleviate the increasing memory footprint
BitmapFactory.Options options = new BitmapFactory.Options();
options.inTempStorage = new byte[32*1024];
options.inDither=false; //Disable Dithering mode
options.inPurgeable=true; //Tell to gc that whether it needs free memory, the Bitmap can be cleared
options.inInputShareable=true; //Which kind of reference will be used to recover the Bitmap data after being clear, when it will be used in the future
options.inPreferredConfig = Bitmap.Config.RGB_565;
Drawable pulled = BitmapDrawable.createFromResourceStream(null, null, conn.getInputStream(), "galleryImage", options);
I am also using weakhashmaps, recycling, System.gc()
and all this successfully PROLONGES the crash. where a device with a 32M heap initially would have only been able to handle a few images before crashing, now it can handle a dozen, but this doesn't fix the problem. The problem is the BitMap method is leaking memory and simply will not clear.
How do I fix this? The images are of size 256x357

If you want to really make sure those Bitmaps are freed, you have to call recycle() on those Bitmaps that are no longer needed. If you need all of them, then recycle least recently used ones (and re-load them, again when needed).

You should try to use drawable.setCallback(null); when you don't need a drawable anymore, because even if you're using a WeakHashMap, they can still be attached to the context through their callback attribute.
See this

I was dealing with ImageView and i solved the memory problem using imageView.clearAnimation(); before to assign the new bitmap and now i have no memory error.

Android: How does Bitmap recycle() work?

Let's say I have loaded an image in a bitmap object like
Bitmap myBitmap = BitmapFactory.decodeFile(myFile);
Now, what will happen if I load another bitmap like
myBitmap = BitmapFactory.decodeFile(myFile2);
What happens to the first myBitmap? Does it get Garbage Collected or do I have to manually garbage collect it before loading another bitmap, eg. myBitmap.recycle()?
Also, is there a better way to load large images and display them one after another while recycling on the way?

The first bitmap is not garbage collected when you decode the second one. Garbage Collector will do it later whenever it decides. If you want to free memory ASAP you should call recycle() just before decoding the second bitmap.
If you want to load really big image you should resample it. Here's an example: Strange out of memory issue while loading an image to a Bitmap object.

I think the problem is this: On pre-Honeycomb versions of Android, the actual raw bitmap data is not stored in VM memory but in native memory instead. This native memory is freed when the corresponding java Bitmap object is GC'd.
However, when you run out of native memory, the dalvik GC isn't triggered, so it is possible that your app uses very little of the java memory, so the dalvik GC is never invoked, yet it uses tons of native memory for bitmaps which eventually causes an OOM error.
At least that's my guess. Thankfully in Honeycomb and later, all bitmap data is stored in the VM so you shouldn't have to use recycle() at all. But for the millions of 2.3 users (fragmentation shakes fist), you should use recycle() wherever possible (a massive hassle). Or alternatively you may be able to invoke the GC instead.

You will need to call myBitmap.recycle() before loading the next image.
Depending on the source of your myFile (E.g. if it is something you have no control over the original size), when loading an image instead of just simply resampling some arbitrary number, you should scale the image to the display size.
if (myBitmap != null) {
myBitmap.recycle();
myBitmap = null;
}
Bitmap original = BitmapFactory.decodeFile(myFile);
myBitmap = Bitmap.createScaledBitmap(original, displayWidth, displayHeight, true);
if (original != myBitmap)
original.recycle();
original = null;
I cache the displayWidth & displayHeight in a static that I initialized at the start of my Activity.
Display display = getWindowManager().getDefaultDisplay();
displayWidth = display.getWidth();
displayHeight = display.getHeight();

Once bitmap had been loaded in memory , in fact it was made by two part data.
First part include some information about bitmap , another part include information about pixels of bitmap( it is maked up by byte array).
First part exisits in Java used memory, second part exisits in C++ used memory. It can use each other's memory directly.
Bitmap.recycle() is used to free the memory of C++.
If you only do that,the GC will collection the part of java and the memory of C is always used.

Timmmm was right.
according to :
http://developer.android.com/training/displaying-bitmaps/cache-bitmap.html
In addition, prior to Android 3.0 (API Level 11), the backing data of a bitmap was stored in native memory which is not released in a predictable manner, potentially causing an application to briefly exceed its memory limits and crash.

OutOfMemoryError: bitmap size exceeds VM budget :- Android [duplicate]

This question already has answers here:
Closed 10 years ago.
Possible Duplicate:
Android: Strange out of memory issue while loading an image to a Bitmap object
i am downloading images from Url and displaying them. At download time it is giving
out of memory error : bitmap size exceeds VM budget.
I am using drawable. Code is below:
HttpClient httpclient= new DefaultHttpClient();
HttpResponse response=(HttpResponse)httpclient.execute(httpRequest);
HttpEntity entity= response.getEntity();
BufferedHttpEntity bufHttpEntity=new BufferedHttpEntity(entity);
InputStream instream = bufHttpEntity.getContent();
Bitmap bm = BitmapFactory.decodeStream(instream);
Bitmap useThisBitmap =
Bitmap.createScaledBitmap(bm,bm.getWidth(),bm.getHeight(), true);
bm.recycle();
BitmapDrawable bt= new BitmapDrawable(useThisBitmap);
System.gc();
Here is the error:
`05-28 14:55:47.251: ERROR/AndroidRuntime(4188):
java.lang.OutOfMemoryError: bitmap size exceeds VM budget`

Use decodeStream(is, outPadding, opts) with
BitmapFactory.Options opts=new BitmapFactory.Options();
opts.inDither=false; //Disable Dithering mode
opts.inPurgeable=true; //Tell to gc that whether it needs free memory, the Bitmap can be cleared
opts.inInputShareable=true; //Which kind of reference will be used to recover the Bitmap data after being clear, when it will be used in the future
opts.inTempStorage=new byte[32 * 1024];

You could check the image size and then downsample it by appropriate factor.
See this question: Handling large Bitmaps

This issue seems to have been reported several times, here and here for instance...
sorry Shalini but if it's the same issue, it seems that there is no solution at all...
The only advice of Romain Guy is to use less memory...
So, good luck to think your stuff differently...

Finally, after resample the image as suggested above, you may call bitmap_file.recycle().

The FACT is that there is a BUG on some Android versions, particularly version 2.1 fails all the time with issues like this one.
I released an app in which I have took a lot of care on resource use. I have even deleted a lot of bitmaps that I were using and now they are created on the fly using graphic primitives. I also recycle bitmaps when no using them. And of course I have checked that I have no memory leaks in my app: the used memory does NOT grow without control, it keeps all the time within reasonable values.
Although I have invest a lot of effort on trying to avoid this problem, I continue getting lots of annoying exceptions like that from 2.1 and 2.1-update1 devices. I am using critercism now to report crashes, and I have seen that It occurs even when the app is using just 4 megabytes of RAM, four times less than the 16M of heap size that every Android device must have for an app -and the fact is that most of devices these days have heap sizes bigger than 16M-.
All my bitmaps have a size of 800x480 pixels, that on the worst case as ARGB_8888 may not occupy more than 1.5MB each one, but it crashes trying to load one when having just 4 megabytes occupied, so there should be at least another 12 MB free. And most of my Bitmaps are loaded as ARGB_4444 that occupies a half of memory, I only use ARGB_8888 when the bitmaps looks really poor with 4444.
So for me it is pretty clear that there is something on these Android versions that is not working fine. 99'9% of this crashes comes from 2.1 and 2.1-update, and the rest may be explained by other punctual reasons.

I've tried many things this is what works.
BitmapFactory.Options opts=new BitmapFactory.Options();
opts.inDither=false; //Disable Dithering mode
opts.inPurgeable=true;
opts.inScale=8;
///after you use your images
System.gc();

This is a practical answer, what I tried to avoid this problem at Run-time. And it also solved my problem.
Runtime.getRuntime().gc();
Calling Garbage Collector is a good Idea.