Guest User

rciovati

a guest
Jul 19th, 2010
559
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. /**
  2.  * This is an object that can load images from a Uri on a thread.
  3.  *
  4.  * @author Jeremy Wadsack
  5.  */
  6. public class ImageThreadLoader {
  7.     public static final String                              LOG_TAG = ImageThreadLoader.class.getCanonicalName();
  8.  
  9.     // Global cache of images.
  10.     // Using SoftReference to allow garbage collector to clean cache if needed
  11.     private final HashMap<String, SoftReference<Drawable>>  Cache   = new HashMap<String, SoftReference<Drawable>>();
  12.  
  13.     private final class QueueItem {
  14.         public Uri                  uri;
  15.         public ImageLoadedListener  listener;
  16.     }
  17.  
  18.     private final ArrayList<QueueItem>  Queue   = new ArrayList<QueueItem>();
  19.  
  20.     private final Handler               handler = new Handler();
  21.     private Thread                      thread;
  22.     private Context                     context;
  23.     private QueueRunner                 runner  = new QueueRunner();            ;
  24.  
  25.     /** Creates a new instance of the ImageThreadLoader */
  26.     public ImageThreadLoader ( Context context ) {
  27.         thread = new Thread( runner );
  28.         this.context = context;
  29.     }
  30.  
  31.     /**
  32.      * Defines an interface for a callback that will handle responses from the
  33.      * thread loader when an image is done being loaded.
  34.      */
  35.     public interface ImageLoadedListener {
  36.         public void imageLoaded ( Drawable imageDrawable );
  37.     }
  38.  
  39.     /**
  40.      * Provides a Runnable class to handle loading the image from the URL and
  41.      * settings the ImageView on the UI thread.
  42.      */
  43.     private class QueueRunner implements Runnable {
  44.         public void run () {
  45.             synchronized ( this ) {
  46.                 while ( Queue.size() > 0 ) {
  47.                     final QueueItem item = Queue.remove( 0 );
  48.  
  49.                     // If in the cache, return that copy and be done
  50.                     if ( Cache.containsKey( item.uri ) && Cache.get( item.uri ) != null ) {
  51.                         // Use a handler to get back onto the UI thread for the
  52.                         // update
  53.                         handler.post( new Runnable() {
  54.                             public void run () {
  55.                                 if ( item.listener != null ) {
  56.                                     SoftReference<Drawable> ref = Cache.get( item.uri.toString() );
  57.                                     if ( ref != null ) {
  58.                                         item.listener.imageLoaded( ref.get() );
  59.                                     }
  60.                                 }
  61.                             }
  62.                         } );
  63.                     }
  64.                     else {
  65.                         final Drawable img = readBitmapFromUri( item.uri );
  66.                         if ( img != null ) {
  67.                             Cache.put( item.uri.toString(), new SoftReference<Drawable>( img ) );
  68.  
  69.                             // Use a handler to get back onto the UI thread for
  70.                             // the update
  71.                             handler.post( new Runnable() {
  72.                                 public void run () {
  73.                                     if ( item.listener != null ) {
  74.                                         item.listener.imageLoaded( img );
  75.                                     }
  76.                                 }
  77.                             } );
  78.                         }
  79.  
  80.                     }
  81.  
  82.                 }
  83.             }
  84.         }
  85.  
  86.     }
  87.  
  88.     /**
  89.      * Queues up a uri to load an image from for a given image view.
  90.      *
  91.      * @param uri
  92.      *            The URI source of the image
  93.      * @param callback
  94.      *            The listener class to call when the image is loaded
  95.      * @throws MalformedURLException
  96.      *             If the provided uri cannot be parsed
  97.      * @return A Bitmap image if the image is in the cache, else null.
  98.      */
  99.     public Drawable loadImage ( final String uri, final ImageLoadedListener listener ) {
  100.         // If it's in the cache, just get it and quit it
  101.         if ( Cache.containsKey( uri ) ) {
  102.             SoftReference<Drawable> ref = Cache.get( uri );
  103.             if ( ref != null ) {
  104.                 return ref.get();
  105.             }
  106.         }
  107.  
  108.         QueueItem item = new QueueItem();
  109.         item.uri = Uri.parse( uri );
  110.         item.listener = listener;
  111.         Queue.add( item );
  112.  
  113.         // start the thread if needed
  114.         if ( thread.getState() == State.NEW ) {
  115.             thread.start();
  116.         }
  117.         else if ( thread.getState() == State.TERMINATED ) {
  118.             thread = new Thread( runner );
  119.             thread.start();
  120.         }
  121.         return null;
  122.     }
  123.  
  124.     public Drawable readBitmapFromUri ( Uri uri ) {
  125.         try {
  126.             return Drawable.createFromStream( context.getContentResolver().openInputStream( uri ), null );
  127.         }
  128.         catch ( Exception e ) {
  129.             return null;
  130.         }
  131.     }
  132.  
  133. }
RAW Paste Data