Solution for OutOfMemoryError: bitmap size exceeds VM budget

Some days ago I was facing this OutOfMemoryError error when developing an Android application. Then I Google’d it and found the reason that causes this type of error: I am using too much images and they are not released, being kept in memory and eventually the memory gets full.

According to Android Developers your device has at least 16MB of heap space (T-Mobile G1) for storing your application data. But as Yekmer said in  Yekmer’s Posterous , images are not stored in the heap space. The space reserved for images in an Android application is very small, and having a big application using a lot of images, may easily lead to the OutOfMemoryError.

So lets see an example.

Imagine that I want an application that do something. For doing “something”, the user needs to pass through a series of steps, lets say 10. So I create 10 activities, one leading to another. But because my application is very awesome, I want each activity to have a different background image, and some other image in it. Both images have decent resolutions (because I want to have a minimum image quality for big resolution devices). Also there is a button on each, that will move to the next activity. Both background and the image are configured in the layout xml of the activity.

Everything seems nice and simple. But when you run it, you may reach activity 8 or 9, never reaching the 10th Activity, because you may face the OutOfMemoryError. So what can I do? I really need those 10 steps, and I want the images to be stored, because I want to be able to press “back” and return to my previous activity!

This problem gave me a lot of headaches, and I had to search a lot for a decent solution. The solution is actually very simple: If I am storing a lot of images, and each Activity has 2 images, and only 1 activity is shown at a time, I could only store 2 images in 2 global variables, and all Activities would reuse those 2 images. Whenever it’s needed to go to the next Activity, that Activity would access to the global variables, changing its value, and then use them.

The only thing I need to do is:

Store the two images at the Application class (So they can accessed from all the Activities)

public class MyApp extends Application {
   private ImageView img; // the image
   private RelativeLayout bgimg; // layout of the activity
   private Bitmap nav; // the image in the Bitmap format
   private Bitmap background; // background in the Bitmap format
   private BitmapDrawable bg; // background in the Drawable format
}

I need also to create two methods at the Application class for each type of image: One that free the images, and other to allocate the new ones, replacing the previous one.

So for the background we have

public void loadBackground(int id) {
   background = BitmapFactory.decodeStream(getResources().openRawResource(id));
   bg = new BitmapDrawable(background);
   bgimg.setBackgroundDrawable(bg);
}
public void unloadBackground() {
   if (bgimg != null)
   bgimg.setBackgroundDrawable(null);
   if (bg!= null) {
      background.recycle();
   }
   bg = null;
}

and for the second image we have

public void loadBitmap(int id) {
   nav = BitmapFactory.decodeStream(getResources().openRawResource(id));
   img.setImageBitmap(nav);
}
public void unloadBitmap() {
   if (img != null)
   img.setImageBitmap(null);
   if (nav!= null) {
      nav.recycle();
   }
   nav = null;
}

I also created this two methods in the Application class to simplify the code at the Activities:

public void setBackground(RelativeLayout i, int sourceid) {
   unloadBackground();
   bgimg = i;
   loadBackground(sourceid);
}

public void setImage(ImageView i, int sourceid) {
   unloadBitmap();
   img = i;
   loadBitmap(sourceid);
}

Now we are going to call this methods in each Activity. Since we want to release the images from the last Activity to save space, we will call this methods at the onCreate() method, and because we may press the back button to go back to the previous activity, we want to call this methods at the onResume() methods, sou you will need to override it.

public class Activity1 extends Activity {
   private ImageView img; // The second image
   private MyApp app;
   private int navid = R.id.imageView1; // id of the imageView
   private int navdid = R.drawable.secondimage; // id of the image drawable
   private int bgid = R.drawable.bg1; // id of the background drawable
   private int layoutid = R.id.layout1; // id of the activity layout
   private RelativeLayout layout; // the layout of the activity

   @Override
   public void onCreate(Bundle savedInstanceState) {
      super.onCreate(savedInstanceState);
      setContentView(R.layout.l1);
      app = (MyApp)getApplication();
      Button b = (Button) findViewById(R.id.button1);
      img = (ImageView)findViewById(navid);
      app.setImage(img, navdid); // free last image, and store new one
      layout = (RelativeLayout) findViewById(layoutid);
      app.setBackground(layout, bgid); // free last background, and store new one
      ...
   }
   @Override
   protected void onResume() {
      super.onResume();
      img = (ImageView)findViewById(navid);
      app.setImage(img, navdid);
      layout = (RelativeLayout) findViewById(layoutid);
      app.setBackground(layout, bgid);
   }
}

And that’s all. With this implemented in each Activity, you will have at most, 2 images loaded in your application, when in theory you would need to have 20!

The disadvantages of using this implementation are that the application may get a bit slower when going from one Activity to another, and when it goes, you may see the images disappearing before the screen changes to the new one. One solution for this is that instead of storing just two images, you buffer 3 pairs: the current pair for the present Activity, and the other two pairs for the previous Activity and the following Activity. It will be required a little bit more space, but you wouldn’t experience the images disappearing when changing between Activities.

I hope this post had helped you!