Android Open Source - HomeMovies Image Loader

From Project

Back to project page HomeMovies.
License

The source code is released under:
MIT License
If you think the Android project HomeMovies listed in this page is inappropriate, such as containing malicious code/tools or violating the copyright, please email info at java2s dot com, thanks.
Java Source Code

package il.co.All4Students.homemovies.util.imageWeb;
//from  w w  w .  j av a2s . c o  m
import static il.co.All4Students.homemovies.app.AppConstants.LOG_TAG_ImageLoader;
import il.co.All4Students.homemovies.R;
import il.co.All4Students.homemovies.util.log.util.AppLog;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
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.app.Activity;
import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.widget.ImageView;

/**
 * 
 * @author Arkadi Yoskovitz
 * @date 2013-02-08
 */
public class ImageLoader {

  // Attributes
  MemoryCache memoryCache = new MemoryCache();
  FileCache fileCache;
  private Map<ImageView, String> imageViews = Collections
      .synchronizedMap(new WeakHashMap<ImageView, String>());
  final int stub_id = R.drawable.ic_list_placeholder;
  ExecutorService executorService;
  private Context mContext;

  // Constractors
  public ImageLoader(Context context) {
    fileCache = new FileCache(context);
    this.mContext = context;
    executorService = Executors.newFixedThreadPool(5);
  }

  // Inner Classes
  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() {
      if (imageViewReused(photoToLoad)) {
        return;
      }
      Bitmap bmp = getBitmap(photoToLoad.url);
      memoryCache.put(photoToLoad.url, bmp);
      if (imageViewReused(photoToLoad)) {
        return;
      }
      BitmapDisplayer bd = new BitmapDisplayer(bmp, photoToLoad);
      Activity activity = (Activity) photoToLoad.imageView.getContext();
      activity.runOnUiThread(bd);
    }
  }

  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);
      }
    }
  }

  // Additional Methods

  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);

    // from SD cache
    Bitmap b = decodeFile(f);
    if (b != null) {
      return b;
    }

    // from web
    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);

      final int buffer_size = 1024;
      try {
        byte[] bytes = new byte[buffer_size];
        for (;;) {
          int count = is.read(bytes, 0, buffer_size);
          if (count == -1)
            break;
          os.write(bytes, 0, count);
        }
      } catch (Exception ex) {
        ex.printStackTrace();
      } finally {
        os.close();
        bitmap = decodeFile(f);
      }
      return bitmap;
    } catch (Throwable ex) {
      ex.printStackTrace();
      if (ex instanceof OutOfMemoryError) {
        memoryCache.clear();
      }
      return null;
    }
  }

  private Bitmap decodeFile(File f) {
    try {
      // decode image size
      BitmapFactory.Options options = new BitmapFactory.Options();
      options.inJustDecodeBounds = true;
      BitmapFactory.decodeStream(new FileInputStream(f), null, options);

      // Find the correct scale value. It should be the power of 2.
      final int REQUIRED_SIZE = 70;
      int width_tmp = options.outWidth, height_tmp = options.outHeight;
      int scale = 1;
      while (true) {
        if (width_tmp / 2 < REQUIRED_SIZE
            || height_tmp / 2 < REQUIRED_SIZE) {
          break;
        }
        width_tmp /= 2;
        height_tmp /= 2;
        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) {
      AppLog.log(mContext, LOG_TAG_ImageLoader, e.getMessage());
    }
    return null;
  }

  boolean imageViewReused(PhotoToLoad photoToLoad) {
    String tag = imageViews.get(photoToLoad.imageView);
    if (tag == null || !tag.equals(photoToLoad.url)) {
      return true;
    }
    return false;
  }

  public void clearCache() {
    memoryCache.clear();
    fileCache.clear();
  }
}
Java Source Code List
