title: need help identifying this exception on android app
body: <p>working with my android app, i get this exception when opening an activity from another activity. i need your help identifying where on my code should I begin to solve the issue:</p>
  
  <pre><code>04-16 19:55:43.014: I/MemoryCache(1083): MemoryCache will use up to 4.0MB
  04-16 19:55:43.044: D/AndroidRuntime(1083): Shutting down VM
  04-16 19:55:43.054: W/dalvikvm(1083): threadid=1: thread exiting with uncaught exception (group=0xb4a53ba8)
  04-16 19:55:43.124: E/AndroidRuntime(1083): FATAL EXCEPTION: main
  04-16 19:55:43.124: E/AndroidRuntime(1083): Process: com.solinpromex.vivegrancanaria, PID: 1083
  04-16 19:55:43.124: E/AndroidRuntime(1083): java.lang.RuntimeException: Unable to instantiate activity ComponentInfo{com.solinpromex.vivegrancanaria/com.solinpromex.vivegrancanaria.Empresas_SingleItemView}: java.lang.NullPointerException
  04-16 19:55:43.124: E/AndroidRuntime(1083):     at android.app.ActivityThread.performLaunchActivity(ActivityThread.java:2121)
  04-16 19:55:43.124: E/AndroidRuntime(1083):     at android.app.ActivityThread.handleLaunchActivity(ActivityThread.java:2245)
  04-16 19:55:43.124: E/AndroidRuntime(1083):     at android.app.ActivityThread.access$800(ActivityThread.java:135)
  04-16 19:55:43.124: E/AndroidRuntime(1083):     at android.app.ActivityThread$H.handleMessage(ActivityThread.java:1196)
  04-16 19:55:43.124: E/AndroidRuntime(1083):     at android.os.Handler.dispatchMessage(Handler.java:102)
  04-16 19:55:43.124: E/AndroidRuntime(1083):     at android.os.Looper.loop(Looper.java:136)
  04-16 19:55:43.124: E/AndroidRuntime(1083):     at android.app.ActivityThread.main(ActivityThread.java:5017)
  04-16 19:55:43.124: E/AndroidRuntime(1083):     at java.lang.reflect.Method.invokeNative(Native Method)
  04-16 19:55:43.124: E/AndroidRuntime(1083):     at java.lang.reflect.Method.invoke(Method.java:515)
  04-16 19:55:43.124: E/AndroidRuntime(1083):     at com.android.internal.os.ZygoteInit$MethodAndArgsCaller.run(ZygoteInit.java:779)
  04-16 19:55:43.124: E/AndroidRuntime(1083):     at com.android.internal.os.ZygoteInit.main(ZygoteInit.java:595)
  04-16 19:55:43.124: E/AndroidRuntime(1083):     at dalvik.system.NativeStart.main(Native Method)
  04-16 19:55:43.124: E/AndroidRuntime(1083): Caused by: java.lang.NullPointerException
  04-16 19:55:43.124: E/AndroidRuntime(1083):     at android.content.ContextWrapper.getCacheDir(ContextWrapper.java:230)
  04-16 19:55:43.124: E/AndroidRuntime(1083):     at com.solinpromex.vivegrancanaria.FileCache.&lt;init&gt;(FileCache.java:17)
  04-16 19:55:43.124: E/AndroidRuntime(1083):     at com.solinpromex.vivegrancanaria.ImageLoader.&lt;init&gt;(ImageLoader.java:34)
  04-16 19:55:43.124: E/AndroidRuntime(1083):     at com.solinpromex.vivegrancanaria.Empresas_SingleItemView.&lt;init&gt;(Empresas_SingleItemView.java:16)
  04-16 19:55:43.124: E/AndroidRuntime(1083):     at java.lang.Class.newInstanceImpl(Native Method)
  04-16 19:55:43.124: E/AndroidRuntime(1083):     at java.lang.Class.newInstance(Class.java:1208)
  04-16 19:55:43.124: E/AndroidRuntime(1083):     at android.app.Instrumentation.newActivity(Instrumentation.java:1061)
  04-16 19:55:43.124: E/AndroidRuntime(1083):     at android.app.ActivityThread.performLaunchActivity(ActivityThread.java:2112)
  04-16 19:55:43.124: E/AndroidRuntime(1083):     ... 11 more
  </code></pre>
  
  <p>EDITED: Added Empresa.SingleItemView.java:</p>
  
  <pre><code>import android.app.Activity;
  import android.content.Intent;
  import android.os.Bundle;
  import android.widget.ImageView;
  import android.widget.TextView;
  
  public class Empresas_SingleItemView extends Activity {
      // Declare Variables
      String valoracionEmpresa;
      String nombreEmpresa;
      String direccionEmpresa;
      String imagenstrImagen;
      String position;
      ImageLoader imageLoader = new ImageLoader(this);
  
      @Override
      public void onCreate(Bundle savedInstanceState) {
          super.onCreate(savedInstanceState);
          // Get the view from singleitemview.xml
          setContentView(R.layout.empresas_singleitemview);
  
          Intent i = getIntent();
          // Get the result of rank
          valoracionEmpresa = i.getStringExtra("valoracionEmpresa");
          // Get the result of country
          nombreEmpresa = i.getStringExtra("nombreEmpresa");
          // Get the result of population
          direccionEmpresa = i.getStringExtra("direccionEmpresa");
          // Get the result of flag
          imagenstrImagen = i.getStringExtra("strImagen");
  
          // Locate the TextViews in singleitemview.xml
          TextView txtvaloracionempresa = (TextView) findViewById(R.id.valoracionEmpresa);
          TextView txtnombreempresa = (TextView) findViewById(R.id.nombreEmpresa);
          TextView txtdireccionempresa = (TextView) findViewById(R.id.direccionEmpresa);
  
          // Locate the ImageView in singleitemview.xml
          ImageView imagenEmpresa = (ImageView) findViewById(R.id.strImagen);
  
          // Set results to the TextViews
          txtvaloracionempresa.setText(valoracionEmpresa);
          txtnombreempresa.setText(nombreEmpresa);
          txtdireccionempresa.setText(direccionEmpresa);
  
          // Capture position and set results to the ImageView
          // Passes flag images URL into ImageLoader.class
          imageLoader.DisplayImage(imagenstrImagen, imagenEmpresa);
      }
  }
  </code></pre>
  
  <p>Added FileCache.java</p>
  
  <pre><code>import java.io.File;
  import android.content.Context;
  
  public class FileCache {
  
      private File cacheDir;
  
      public FileCache(Context context) {
          // Find the dir to save cached images
          if (android.os.Environment.getExternalStorageState().equals(
                  android.os.Environment.MEDIA_MOUNTED))
              cacheDir = new File(
                      android.os.Environment.getExternalStorageDirectory(),
                      "JsonParseTutorialCache");
          else
              cacheDir = context.getCacheDir();
          if (!cacheDir.exists())
              cacheDir.mkdirs();
      }
  
      public File getFile(String url) {
          String filename = String.valueOf(url.hashCode());
          // String filename = URLEncoder.encode(url);
          File f = new File(cacheDir, filename);
          return f;
  
      }
  
      public void clear() {
          File[] files = cacheDir.listFiles();
          if (files == null)
              return;
          for (File f : files)
              f.delete();
      }
  
  }
  </code></pre>
  
  <p>Added ImageLoader.java</p>
  
  <pre><code>import java.io.File;
  import java.io.FileInputStream;
  import java.io.FileNotFoundException;
  import java.io.FileOutputStream;
  import java.io.IOException;
  import java.io.InputStream;
  import java.io.OutputStream;
  import java.net.HttpURLConnection;
  import java.net.URL;
  import java.util.Collections;
  import java.util.Map;
  import java.util.WeakHashMap;
  import java.util.concurrent.ExecutorService;
  import java.util.concurrent.Executors;
  import android.os.Handler;
  import android.content.Context;
  import android.graphics.Bitmap;
  import android.graphics.BitmapFactory;
  import android.widget.ImageView;
  
  public class ImageLoader {
  
      MemoryCache memoryCache = new MemoryCache();
      FileCache fileCache;
      private Map&lt;ImageView, String&gt; imageViews = Collections
              .synchronizedMap(new WeakHashMap&lt;ImageView, String&gt;());
      ExecutorService executorService;
      // Handler to display images in UI thread
      Handler handler = new Handler();
  
      public ImageLoader(Context context) {
          fileCache = new FileCache(context);
          executorService = Executors.newFixedThreadPool(5);
      }
  
      final int stub_id = R.drawable.temp_img;
  
      public void DisplayImage(String url, ImageView imageView) {
          imageViews.put(imageView, url);
          Bitmap bitmap = memoryCache.get(url);
          if (bitmap != null)
              imageView.setImageBitmap(bitmap);
          else {
              queuePhoto(url, imageView);
              imageView.setImageResource(stub_id);
          }
      }
  
      private void queuePhoto(String url, ImageView imageView) {
          PhotoToLoad p = new PhotoToLoad(url, imageView);
          executorService.submit(new PhotosLoader(p));
      }
  
      private Bitmap getBitmap(String url) {
          File f = fileCache.getFile(url);
  
          Bitmap b = decodeFile(f);
          if (b != null)
              return b;
  
          // Download Images from the Internet
          try {
              Bitmap bitmap = null;
              URL imageUrl = new URL(url);
              HttpURLConnection conn = (HttpURLConnection) imageUrl
                      .openConnection();
              conn.setConnectTimeout(30000);
              conn.setReadTimeout(30000);
              conn.setInstanceFollowRedirects(true);
              InputStream is = conn.getInputStream();
              OutputStream os = new FileOutputStream(f);
              Utils.CopyStream(is, os);
              os.close();
              conn.disconnect();
              bitmap = decodeFile(f);
              return bitmap;
          } catch (Throwable ex) {
              ex.printStackTrace();
              if (ex instanceof OutOfMemoryError)
                  memoryCache.clear();
              return null;
          }
      }
  
      // 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;
              FileInputStream stream1 = new FileInputStream(f);
              BitmapFactory.decodeStream(stream1, null, o);
              stream1.close();
  
              // Find the correct scale value. It should be the power of 2.
              // Recommended Size 512
              final int REQUIRED_SIZE = 70;
              int width_tmp = o.outWidth, height_tmp = o.outHeight;
              int scale = 1;
              while (true) {
                  if (width_tmp / 2 &lt; REQUIRED_SIZE
                          || height_tmp / 2 &lt; REQUIRED_SIZE)
                      break;
                  width_tmp /= 2;
                  height_tmp /= 2;
                  scale *= 2;
              }
  
              // Decode with inSampleSize
              BitmapFactory.Options o2 = new BitmapFactory.Options();
              o2.inSampleSize = scale;
              FileInputStream stream2 = new FileInputStream(f);
              Bitmap bitmap = BitmapFactory.decodeStream(stream2, null, o2);
              stream2.close();
              return bitmap;
          } catch (FileNotFoundException e) {
          } catch (IOException e) {
              e.printStackTrace();
          }
          return null;
      }
  
      // Task for the queue
      private class PhotoToLoad {
          public String url;
          public ImageView imageView;
  
          public PhotoToLoad(String u, ImageView i) {
              url = u;
              imageView = i;
          }
      }
  
      class PhotosLoader implements Runnable {
          PhotoToLoad photoToLoad;
  
          PhotosLoader(PhotoToLoad photoToLoad) {
              this.photoToLoad = photoToLoad;
          }
  
          @Override
          public void run() {
              try {
                  if (imageViewReused(photoToLoad))
                      return;
                  Bitmap bmp = getBitmap(photoToLoad.url);
                  memoryCache.put(photoToLoad.url, bmp);
                  if (imageViewReused(photoToLoad))
                      return;
                  BitmapDisplayer bd = new BitmapDisplayer(bmp, photoToLoad);
                  handler.post(bd);
              } catch (Throwable th) {
                  th.printStackTrace();
              }
          }
      }
  
      boolean imageViewReused(PhotoToLoad photoToLoad) {
          String tag = imageViews.get(photoToLoad.imageView);
          if (tag == null || !tag.equals(photoToLoad.url))
              return true;
          return false;
      }
  
      // Used to display bitmap in the UI thread
      class BitmapDisplayer implements Runnable {
          Bitmap bitmap;
          PhotoToLoad photoToLoad;
  
          public BitmapDisplayer(Bitmap b, PhotoToLoad p) {
              bitmap = b;
              photoToLoad = p;
          }
  
          public void run() {
              if (imageViewReused(photoToLoad))
                  return;
              if (bitmap != null)
                  photoToLoad.imageView.setImageBitmap(bitmap);
              else
                  photoToLoad.imageView.setImageResource(stub_id);
          }
      }
  
      public void clearCache() {
          memoryCache.clear();
          fileCache.clear();
      }
  
  }
  </code></pre>