Bitmap Size Exceeds Vm Budget Error Android

bitmap size exceeds Vm budget error android

I also had the same problem OOME because of bitmaps.

When orientation changes from PORTRAIT to LANDSCAPE and vice-versa, the previous UI is completely discarded, and a new UI is loaded and displayed, In this case if you are using many bitmaps in your app, you need to release them at proper places.

To check the orientation of your device, please see this: Check orientation on Android phone

In your case, you need to clear bitmaps during orientation change.

On above link you can found, how to get the current orientation. So on each orientation change, call your above code that cleans up the bitmaps.

Now, when we check the logcat, there is always a log comes up saying GC_, but I could not understand that, so
I found an amazing doc on memory leak issue: http://codelog.dexetra.com/getting-around-android-memory-blues

The above link is very useful for your problem.

Now, the OOME occurs when there is memory leak in your app., so to check that, please install the MAT for eclipse. You can find it at: http://www.eclipse.org/mat/downloads.php

Its a bit complicated software but as you go through it, you will understand, its pretty useful software.

Even if this doesn't solves your problem, use the WeakReference for bitmaps.

Please refer this link: How to use WeakReference in Java and Android development?

If I get know some more info, I will update this post.

Please update your post, if you get solution to your problem.

Thank you :)

how to fix error in bitmap size exceeds VM budget

narasimha , I suppose may be this post will help you

android-strange-out-of-memory-issue

or this
java-lang-outofmemoryerror-bitmap-size-exceeds-vm-budget-android

or may be this
android-java-lang-outofmemoryerror

& there are more questions already there

Caused by: java.lang.OutOfMemoryError: bitmap size exceeds VM budget

I guess the problem is not in your layout; the problem is somewhere else in your code. And you are probably leaking context somewhere.

Other probable reason is that you must be creating bulky multiple objects while parsing your XML (as you mentioned this occurs the first time when you parse XML). Though Java has auto garbage collection approach, but still you can not completely rely on it. It is a good practice to nullify your collection instance or clear your objects content when you don't need them any more.

But still I have prepared a list of important points which you should remember while dealing with bitmaps on Android.

1) You can call recycle on each bitmap and set them to null. (bitmap.recycle() will release all the memory used by this bitmap, but it does not nullify the bitmap object).

2) You can also unbind the drawables associated with layouts when an activity is destroyed. Try the code given below and also have a look at this link link.

    private void unbindDrawables(View view) {
        if (view.getBackground() != null) {
            view.getBackground().setCallback(null);
        }
        if (view instanceof ViewGroup) {
            for (int i = 0; i < ((ViewGroup) view).getChildCount(); i++) {
                unbindDrawables(((ViewGroup) view).getChildAt(i));
            }
            ((ViewGroup) view).removeAllViews();
        }
    }

// Call this method from onDestroy()

    void onDestroy() {
        super.onDestroy();
        unbindDrawables(findViewById(R.id.RootView));
        System.gc();
    }

3) You can convert your hashmaps to WeakHashmaps, so that its memory would get released when the system runs low on memory.

4) You can scale/resize all your bitmaps. To scale bitmaps you can try something like this:

    BitmapFactory.Options options = new BitmapFactory.Options();
    options.inSampleSize = 8;
    Bitmap preview_bitmap=BitmapFactory.decodeStream(is, null, options);

This inSampleSize option reduces memory consumption.

Here's a complete method. First it reads the image size without decoding the content itself. Then it finds the best inSampleSize value; it should be a power of 2. And finally the image is decoded.

// Decodes image and scales it to reduce memory consumption
private Bitmap decodeFile(File f){
    try {
        // Decode image size
        BitmapFactory.Options o = new BitmapFactory.Options();
        o.inJustDecodeBounds = true;
        BitmapFactory.decodeStream(new FileInputStream(f),null,o);

        // The new size we want to scale to
        final int REQUIRED_SIZE=70;

        // Find the correct scale value. It should be the power of 2.
        int scale=1;
        while(o.outWidth/scale/2 >= REQUIRED_SIZE && o.outHeight/scale/2 >= REQUIRED_SIZE)
            scale*=2;

        // Decode with inSampleSize
        BitmapFactory.Options o2 = new BitmapFactory.Options();
        o2.inSampleSize=scale;
        return BitmapFactory.decodeStream(new FileInputStream(f), null, o2);
    }
    catch (FileNotFoundException e) {
    }
    return null;
}

Have a look at this link..

5) You can override onLowMemory() method in an activity which gets a call when entire system runs low on memory. You can release a few resources there.

6) You can make your objects SoftReference or Weakreference, so that they get released in a low-memory condition.

A very common memory leak that I observed is due to the implementation of inner classes and implementing Handler in Activity. This links talks about the same in more detail.

I hope this helps to eliminate your problem.

Bitmap size exceeds VM budget

This is very common question you see on SO. It seems while loading the image, available memory is low. Make sure you are not keeping for long references for images, which allows dalvik to reclaim the memory from unused images (or) objects.

java.lang.OutOfMemoryError: bitmap size exceeds VM budget

Use BitmapFactory.Options.inSampleSize and set it to a value >1 which will scale it down.

bitmap size exceeds VM budget in android

I ran into a similar problem when selecting images from my EVO ... off the SD Card. The camera saves those images at over 1MB a piece, and in some cases close to 3 MB. Ironically, the size of the bitmap the Intent sends to you when "taking a picture" is only about 40 Kb.

The solution I came up with was:

BitmapFactory.Options options = new BitmapFactory.Options();
options.inSampleSize = 2;    // this will cut the sampling by 50%
Bitmap bitmap = BitmapFactory.decodeFile( imageFilePath, options );

I was able to take pictures and cut them down to less than 100 Kb by increasing the factor number, and the images were still pretty good quality.

The bottom line here is it prevented OOME errors, and thus prevent me from crushing the JVM by exceeding the heap allocation. Simple - effective.

You might find this an interesting read also: BitmapFactory OOM driving me nuts

Android: OutofMemoryError: bitmap size exceeds VM budget with no reason I can see

I think there's nothing special in your case. There's just not enough memory. You can't have several 600x800 bitmaps in memory, they consume too much memory. You should save them to SD and load to memory on demand. I think that's exactly what you do.

One thing you should be aware of: DDMS displays java heap memory consumption. But there's also native memory that is not displayed in DDMS. And bitmaps as far as I understand are created in native memory. So DDMS is just a bad tool to track these memory issues. You just need to be sure that you free your memory, that images are collected by Garbage Collector after you don't need them any more.

Garbage Collector works on it's own schedule. That's why you should call Bitmap.recycle() method on bitmaps that you don't need any more. This method frees exactly the native memory that you run out of. This way you don't depend on GC and you can free largest piece of memory as soon as possible.

First of all you should ensure that you don't leak bitmaps.

Here's a nice post on memory allocations, it can help you to dig deeper

---

Related Topics