Android Open Source - Android-Display-Images-from-SD-Card-Tutorial Image Loader

• Back to Image/display  ↑

From Project

Back to project page Android-Display-Images-from-SD-Card-Tutorial.

License

The source code is released under:

Apache License

Java Source Code

package com.androidbegin.sdimagetutorial;
//from  w  ww.j  a  v  a2  s . co m
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
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();
  private Map<ImageView, String> imageViews = Collections
      .synchronizedMap(new WeakHashMap<ImageView, String>());
  ExecutorService executorService;
  // Handler to display images in UI thread
  Handler handler = new Handler();

  public ImageLoader(Context context) {
    executorService = Executors.newFixedThreadPool(5);
  }

  final int tempimage = R.drawable.temp_image;

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

  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 = new File(url);
    Bitmap b = decodeFile(f);
    if (b != null) {
      return b;
    }
    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 = 512;
      int width_tmp = o.outWidth, height_tmp = o.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;
      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(tempimage);
    }
  }

  public void clearCache() {
    memoryCache.clear();
  }

}

Java Source Code List

• Back to Image/display  ↑