For many times I faced this error, and sometimes its cause was different from the previous one. It may occur anytime, and it is the R cannot be resolved error.

There are two things (at least that I know or remember, I’ll keep this post updated as soon as I find more) that may have cause it:

- The Eclipse imported the wrong R class file

- There is some error at some XML file that is preventing Eclipse to build the project and preventing the generation of the R class.

So for the first issue, if you see at the import section

import android.R;

delete it.

For the second issue, you have to solve your errors at the XML files first, and then when you build your project, your R error will be gone. (You may have to clean your project first).

Hope it helps!

Today I had this problem where I needed to create some TextViews inside a TableRow, but I needed to specify its setMinWidth with some value in the SP metrics, like you do at the XML file: setWidth=”100sp”. The problem is that setMinWidth or setWidth are called giving a number in pixels. So I searched a little bit and found this simple solution.

The goal is to calculate the number of pixels according to a given value in the SP metrics. Converting 20sp into pixels is done by doing

TextView tv0 = new TextView(this);
int px = (int) TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_SP, 20, getResources().getDisplayMetrics());
tv0.setMinimumWidth(px);

And that’s it!
If you want it with the DIP metrics, you just need to change the TypedValue from TypedValue.COMPLEX_UNIT_SP to TypedValue.COMPLEX_UNIT_DIP or whatever other metric you want to use.

Hope it was helpful.

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.setNavigation(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.setNavigation(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!

Hi developer!

My name is João Cruz, and I am an Android developer.

When I finished my Mobile Computation course at Instituto Superior Técnico in Lisbon (Portugal) I found myself loving the Android platform and then started to go deeper into application development, by doing some small applications and later being an employee at Beware Mobile.

Doing so, I began developing bigger applications, which gave me a lot of headaches due to many Android development related issues, where even Google didn’t help that much to solve.

So I created this blog to share to you some problems I found during development of applications, and how I solved them. Some are commons problems, other are more sophisticated. I hope this blog helps you out at some point!