title: scale the size of downloaded image to fit the imageview
body: <p>This is my first time working with a ListView, and here is my problem : 
  I have an Imageloader class that downloads, decodes and scales images from the internet (from parse.com). The whole process works fine, but when the image is loaded on the imageview it doesn't fit the parent width...I'm trying to have something similar to instagram's display with a square image that fills the entire screen regardless of the used device.</p>
  
  <p>this is what I have actually : <a href="http://i.imgur.com/OMDyG8I.jpg" rel="nofollow">http://i.imgur.com/OMDyG8I.jpg</a>
  this is what I want : <a href="http://i.imgur.com/nGHADzK.jpg" rel="nofollow">http://i.imgur.com/nGHADzK.jpg</a></p>
  
  <p>I used the Imageloader.java that I found on a tutorial and I don't really understandd how it really works. So if you guys could explain to me how it does so i can adapt it to have a square full screen image on my listview. thanks in advance :)</p>
  
  <p>this is my ImageLoader.java (Nothing special on my layout for now...only an imageview with match-parent height and witdh): </p>
  
  <pre><code>package com.hichamridouane.smartshop;
  
  
  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;
  importenter code here 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.
          final int REQUIRED_SIZE = 600;
          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>