package com.example.uil; 
 
import com.nostra13.universalimageloader.core.ImageLoader; 
import com.nostra13.universalimageloader.core.ImageLoaderConfiguration; 
 
import android.app.Application; 
 
public class MyApplication extends Application { 
 
 @Override 
 public void onCreate() { 
  super.onCreate(); 
 
  //创建默认的ImageLoader配置参数 
  ImageLoaderConfiguration configuration = ImageLoaderConfiguration 
    .createDefault(this); 
   
  //Initialize ImageLoader with configuration. 
  ImageLoader.getInstance().init(configuration); 
 } 
 
} 

File cacheDir = StorageUtils.getCacheDirectory(context); 
ImageLoaderConfiguration config = new ImageLoaderConfiguration.Builder(context) 
  .memoryCacheExtraOptions(480, 800) // default = device screen dimensions 
  .diskCacheExtraOptions(480, 800, CompressFormat.JPEG, 75, null) 
  .taskExecutor(...) 
  .taskExecutorForCachedImages(...) 
  .threadPoolSize(3) // default 
  .threadPriority(Thread.NORM_PRIORITY - 1) // default 
  .tasksProcessingOrder(QueueProcessingType.FIFO) // default 
  .denyCacheImageMultipleSizesInMemory() 
  .memoryCache(new LruMemoryCache(2 * 1024 * 1024)) 
  .memoryCacheSize(2 * 1024 * 1024) 
  .memoryCacheSizePercentage(13) // default 
  .diskCache(new UnlimitedDiscCache(cacheDir)) // default 
  .diskCacheSize(50 * 1024 * 1024) 
  .diskCacheFileCount(100) 
  .diskCacheFileNameGenerator(new HashCodeFileNameGenerator()) // default 
  .imageDownloader(new BaseImageDownloader(context)) // default 
  .imageDecoder(new BaseImageDecoder()) // default 
  .defaultDisplayImageOptions(DisplayImageOptions.createSimple()) // default 
  .writeDebugLogs() 
  .build(); 

<manifest> 
 <uses-permission android:name="android.permission.INTERNET" /> 
 <!-- Include next permission if you want to allow UIL to cache images on SD card --> 
 <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" /> 
 ... 
 <application android:name="MyApplication"> 
  ... 
 </application> 
</manifest> 

<?xml version="1.0" encoding="utf-8"?> 
<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android" 
 android:layout_width="fill_parent" 
 android:layout_height="fill_parent"> 
 
 <ImageView 
  android:layout_gravity="center" 
  android:id="@+id/image" 
  android:src="@drawable/ic_empty" 
  android:layout_width="wrap_content" 
  android:layout_height="wrap_content" /> 
 
</FrameLayout> 

final ImageView mImageView = (ImageView) findViewById(R.id.image); 
  String imageUrl = "https://lh6.googleusercontent.com/-55osAWw3x0Q/URquUtcFr5I/AAAAAAAAAbs/rWlj1RUKrYI/s1024/A%252520Photographer.jpg"; 
   
  ImageLoader.getInstance().loadImage(imageUrl, new ImageLoadingListener() { 
    
   @Override 
   public void onLoadingStarted(String imageUri, View view) { 
     
   } 
    
   @Override 
   public void onLoadingFailed(String imageUri, View view, 
     FailReason failReason) { 
     
   } 
    
   @Override 
   public void onLoadingComplete(String imageUri, View view, Bitmap loadedImage) { 
    mImageView.setImageBitmap(loadedImage); 
   } 
    
   @Override 
   public void onLoadingCancelled(String imageUri, View view) { 
     
   } 
  }); 

final ImageView mImageView = (ImageView) findViewById(R.id.image); 
  String imageUrl = "https://lh6.googleusercontent.com/-55osAWw3x0Q/URquUtcFr5I/AAAAAAAAAbs/rWlj1RUKrYI/s1024/A%252520Photographer.jpg"; 
   
  ImageLoader.getInstance().loadImage(imageUrl, new SimpleImageLoadingListener(){ 
 
   @Override 
   public void onLoadingComplete(String imageUri, View view, 
     Bitmap loadedImage) { 
    super.onLoadingComplete(imageUri, view, loadedImage); 
    mImageView.setImageBitmap(loadedImage); 
   } 
    
  }); 

final ImageView mImageView = (ImageView) findViewById(R.id.image); 
  String imageUrl = "https://lh6.googleusercontent.com/-55osAWw3x0Q/URquUtcFr5I/AAAAAAAAAbs/rWlj1RUKrYI/s1024/A%252520Photographer.jpg"; 
   
  ImageSize mImageSize = new ImageSize(100, 100); 
   
  ImageLoader.getInstance().loadImage(imageUrl, mImageSize, new SimpleImageLoadingListener(){ 
 
   @Override 
   public void onLoadingComplete(String imageUri, View view, 
     Bitmap loadedImage) { 
    super.onLoadingComplete(imageUri, view, loadedImage); 
    mImageView.setImageBitmap(loadedImage); 
   } 
    
  }); 

DisplayImageOptions options = new DisplayImageOptions.Builder() 
  .showImageOnLoading(R.drawable.ic_stub) // resource or drawable 
  .showImageForEmptyUri(R.drawable.ic_empty) // resource or drawable 
  .showImageOnFail(R.drawable.ic_error) // resource or drawable 
  .resetViewBeforeLoading(false) // default 
  .delayBeforeLoading(1000) 
  .cacheInMemory(false) // default 
  .cacheOnDisk(false) // default 
  .preProcessor(...) 
  .postProcessor(...) 
  .extraForDownloader(...) 
  .considerExifParams(false) // default 
  .imageScaleType(ImageScaleType.IN_SAMPLE_POWER_OF_2) // default 
  .bitmapConfig(Bitmap.Config.ARGB_8888) // default 
  .decodingOptions(...) 
  .displayer(new SimpleBitmapDisplayer()) // default 
  .handler(new Handler()) // default 
  .build(); 

final ImageView mImageView = (ImageView) findViewById(R.id.image); 
  String imageUrl = "https://lh6.googleusercontent.com/-55osAWw3x0Q/URquUtcFr5I/AAAAAAAAAbs/rWlj1RUKrYI/s1024/A%252520Photographer.jpg"; 
  ImageSize mImageSize = new ImageSize(100, 100); 
   
  //显示图片的配置 
  DisplayImageOptions options = new DisplayImageOptions.Builder() 
    .cacheInMemory(true) 
    .cacheOnDisk(true) 
    .bitmapConfig(Bitmap.Config.RGB_565) 
    .build(); 
   
  ImageLoader.getInstance().loadImage(imageUrl, mImageSize, options, new SimpleImageLoadingListener(){ 
 
   @Override 
   public void onLoadingComplete(String imageUri, View view, 
     Bitmap loadedImage) { 
    super.onLoadingComplete(imageUri, view, loadedImage); 
    mImageView.setImageBitmap(loadedImage); 
   } 
    
  }); 

final ImageView mImageView = (ImageView) findViewById(R.id.image); 
  String imageUrl = "https://lh6.googleusercontent.com/-55osAWw3x0Q/URquUtcFr5I/AAAAAAAAAbs/rWlj1RUKrYI/s1024/A%252520Photographer.jpg"; 
   
  //显示图片的配置 
  DisplayImageOptions options = new DisplayImageOptions.Builder() 
    .showImageOnLoading(R.drawable.ic_stub) 
    .showImageOnFail(R.drawable.ic_error) 
    .cacheInMemory(true) 
    .cacheOnDisk(true) 
    .bitmapConfig(Bitmap.Config.RGB_565) 
    .build(); 
   
  ImageLoader.getInstance().displayImage(imageUrl, mImageView, options); 

public class MyApplication extends Application { 
 
 @Override 
 public void onCreate() { 
  super.onCreate(); 
 
  //创建默认的ImageLoader配置参数 
  ImageLoaderConfiguration configuration = new ImageLoaderConfiguration.Builder(this) 
  .writeDebugLogs() //打印log信息 
  .build(); 
   
   
  //Initialize ImageLoader with configuration. 
  ImageLoader.getInstance().init(configuration); 
 } 
 
} 

imageLoader.displayImage(imageUrl, mImageView, options, new SimpleImageLoadingListener(), new ImageLoadingProgressListener() { 
    
   @Override 
   public void onProgressUpdate(String imageUri, View view, int current, 
     int total) { 
     
   } 
  }); 

//显示图片的配置 
  DisplayImageOptions options = new DisplayImageOptions.Builder() 
    .showImageOnLoading(R.drawable.ic_stub) 
    .showImageOnFail(R.drawable.ic_error) 
    .cacheInMemory(true) 
    .cacheOnDisk(true) 
    .bitmapConfig(Bitmap.Config.RGB_565) 
    .build(); 
   
  final ImageView mImageView = (ImageView) findViewById(R.id.image); 
  String imagePath = "/mnt/sdcard/image.png"; 
  String imageUrl = Scheme.FILE.wrap(imagePath); 
   
//  String imageUrl = "http://img.my.csdn.net/uploads/201309/01/1378037235_7476.jpg"; 
   
  imageLoader.displayImage(imageUrl, mImageView, options); 

//图片来源于Content provider 
  String contentprividerUrl = "content://media/external/audio/albumart/13"; 
   
  //图片来源于assets 
  String assetsUrl = Scheme.ASSETS.wrap("image.png"); 
   
  //图片来源于 
  String drawableUrl = Scheme.DRAWABLE.wrap("R.drawable.image"); 

ImageLoaderConfiguration configuration = new ImageLoaderConfiguration.Builder(this) 
  .memoryCache(new WeakMemoryCache()) 
  .build(); 

package com.nostra13.universalimageloader.cache.memory.impl; 
 
import android.graphics.Bitmap; 
import com.nostra13.universalimageloader.cache.memory.MemoryCacheAware; 
 
import java.util.Collection; 
import java.util.HashSet; 
import java.util.LinkedHashMap; 
import java.util.Map; 
 
/** 
 * A cache that holds strong references to a limited number of Bitmaps. Each time a Bitmap is accessed, it is moved to 
 * the head of a queue. When a Bitmap is added to a full cache, the Bitmap at the end of that queue is evicted and may 
 * become eligible for garbage collection.<br /> 
 * <br /> 
 * <b>NOTE:</b> This cache uses only strong references for stored Bitmaps. 
 * 
 * @author Sergey Tarasevich (nostra13[at]gmail[dot]com) 
 * @since 1.8.1 
 */ 
public class LruMemoryCache implements MemoryCacheAware<String, Bitmap> { 
 
 private final LinkedHashMap<String, Bitmap> map; 
 
 private final int maxSize; 
 /** Size of this cache in bytes */ 
 private int size; 
 
 /** @param maxSize Maximum sum of the sizes of the Bitmaps in this cache */ 
 public LruMemoryCache(int maxSize) { 
  if (maxSize <= 0) { 
   throw new IllegalArgumentException("maxSize <= 0"); 
  } 
  this.maxSize = maxSize; 
  this.map = new LinkedHashMap<String, Bitmap>(0, 0.75f, true); 
 } 
 
 /** 
  * Returns the Bitmap for {@code key} if it exists in the cache. If a Bitmap was returned, it is moved to the head 
  * of the queue. This returns null if a Bitmap is not cached. 
  */ 
 @Override 
 public final Bitmap get(String key) { 
  if (key == null) { 
   throw new NullPointerException("key == null"); 
  } 
 
  synchronized (this) { 
   return map.get(key); 
  } 
 } 
 
 /** Caches {@code Bitmap} for {@code key}. The Bitmap is moved to the head of the queue. */ 
 @Override 
 public final boolean put(String key, Bitmap value) { 
  if (key == null || value == null) { 
   throw new NullPointerException("key == null || value == null"); 
  } 
 
  synchronized (this) { 
   size += sizeOf(key, value); 
   Bitmap previous = map.put(key, value); 
   if (previous != null) { 
    size -= sizeOf(key, previous); 
   } 
  } 
 
  trimToSize(maxSize); 
  return true; 
 } 
 
 /** 
  * Remove the eldest entries until the total of remaining entries is at or below the requested size. 
  * 
  * @param maxSize the maximum size of the cache before returning. May be -1 to evict even 0-sized elements. 
  */ 
 private void trimToSize(int maxSize) { 
  while (true) { 
   String key; 
   Bitmap value; 
   synchronized (this) { 
    if (size < 0 || (map.isEmpty() && size != 0)) { 
     throw new IllegalStateException(getClass().getName() + ".sizeOf() is reporting inconsistent results!"); 
    } 
 
    if (size <= maxSize || map.isEmpty()) { 
     break; 
    } 
 
    Map.Entry<String, Bitmap> toEvict = map.entrySet().iterator().next(); 
    if (toEvict == null) { 
     break; 
    } 
    key = toEvict.getKey(); 
    value = toEvict.getValue(); 
    map.remove(key); 
    size -= sizeOf(key, value); 
   } 
  } 
 } 
 
 /** Removes the entry for {@code key} if it exists. */ 
 @Override 
 public final void remove(String key) { 
  if (key == null) { 
   throw new NullPointerException("key == null"); 
  } 
 
  synchronized (this) { 
   Bitmap previous = map.remove(key); 
   if (previous != null) { 
    size -= sizeOf(key, previous); 
   } 
  } 
 } 
 
 @Override 
 public Collection<String> keys() { 
  synchronized (this) { 
   return new HashSet<String>(map.keySet()); 
  } 
 } 
 
 @Override 
 public void clear() { 
  trimToSize(-1); // -1 will evict 0-sized elements 
 } 
 
 /** 
  * Returns the size {@code Bitmap} in bytes. 
  * <p/> 
  * An entry's size must not change while it is in the cache. 
  */ 
 private int sizeOf(String key, Bitmap value) { 
  return value.getRowBytes() * value.getHeight(); 
 } 
 
 @Override 
 public synchronized final String toString() { 
  return String.format("LruCache[maxSize=%d]", maxSize); 
 } 
} 

/******************************************************************************* 
 * Copyright 2011-2013 Sergey Tarasevich 
 * 
 * Licensed under the Apache License, Version 2.0 (the "License"); 
 * you may not use this file except in compliance with the License. 
 * You may obtain a copy of the License at 
 * 
 * http://www.apache.org/licenses/LICENSE-2.0 
 * 
 * Unless required by applicable law or agreed to in writing, software 
 * distributed under the License is distributed on an "AS IS" BASIS, 
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
 * See the License for the specific language governing permissions and 
 * limitations under the License. 
 *******************************************************************************/ 
package com.nostra13.universalimageloader.cache.disc.impl; 
 
import com.nostra13.universalimageloader.cache.disc.LimitedDiscCache; 
import com.nostra13.universalimageloader.cache.disc.naming.FileNameGenerator; 
import com.nostra13.universalimageloader.core.DefaultConfigurationFactory; 
import com.nostra13.universalimageloader.utils.L; 
 
import java.io.File; 
 
/** 
 * Disc cache limited by total cache size. If cache size exceeds specified limit then file with the most oldest last 
 * usage date will be deleted. 
 * 
 * @author Sergey Tarasevich (nostra13[at]gmail[dot]com) 
 * @see LimitedDiscCache 
 * @since 1.0.0 
 */ 
public class TotalSizeLimitedDiscCache extends LimitedDiscCache { 
 
 private static final int MIN_NORMAL_CACHE_SIZE_IN_MB = 2; 
 private static final int MIN_NORMAL_CACHE_SIZE = MIN_NORMAL_CACHE_SIZE_IN_MB * 1024 * 1024; 
 
 /** 
  * @param cacheDir  Directory for file caching. <b>Important:</b> Specify separate folder for cached files. It's 
  *      needed for right cache limit work. 
  * @param maxCacheSize Maximum cache directory size (in bytes). If cache size exceeds this limit then file with the 
  *      most oldest last usage date will be deleted. 
  */ 
 public TotalSizeLimitedDiscCache(File cacheDir, int maxCacheSize) { 
  this(cacheDir, DefaultConfigurationFactory.createFileNameGenerator(), maxCacheSize); 
 } 
 
 /** 
  * @param cacheDir   Directory for file caching. <b>Important:</b> Specify separate folder for cached files. It's 
  *       needed for right cache limit work. 
  * @param fileNameGenerator Name generator for cached files 
  * @param maxCacheSize  Maximum cache directory size (in bytes). If cache size exceeds this limit then file with the 
  *       most oldest last usage date will be deleted. 
  */ 
 public TotalSizeLimitedDiscCache(File cacheDir, FileNameGenerator fileNameGenerator, int maxCacheSize) { 
  super(cacheDir, fileNameGenerator, maxCacheSize); 
  if (maxCacheSize < MIN_NORMAL_CACHE_SIZE) { 
   L.w("You set too small disc cache size (less than %1$d Mb)", MIN_NORMAL_CACHE_SIZE_IN_MB); 
  } 
 } 
 
 @Override 
 protected int getSize(File file) { 
  return (int) file.length(); 
 } 
} 

/******************************************************************************* 
 * Copyright 2011-2013 Sergey Tarasevich 
 * 
 * Licensed under the Apache License, Version 2.0 (the "License"); 
 * you may not use this file except in compliance with the License. 
 * You may obtain a copy of the License at 
 * 
 * http://www.apache.org/licenses/LICENSE-2.0 
 * 
 * Unless required by applicable law or agreed to in writing, software 
 * distributed under the License is distributed on an "AS IS" BASIS, 
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
 * See the License for the specific language governing permissions and 
 * limitations under the License. 
 *******************************************************************************/ 
package com.nostra13.universalimageloader.cache.disc; 
 
import com.nostra13.universalimageloader.cache.disc.naming.FileNameGenerator; 
import com.nostra13.universalimageloader.core.DefaultConfigurationFactory; 
 
import java.io.File; 
import java.util.Collections; 
import java.util.HashMap; 
import java.util.Map; 
import java.util.Map.Entry; 
import java.util.Set; 
import java.util.concurrent.atomic.AtomicInteger; 
 
/** 
 * Abstract disc cache limited by some parameter. If cache exceeds specified limit then file with the most oldest last 
 * usage date will be deleted. 
 * 
 * @author Sergey Tarasevich (nostra13[at]gmail[dot]com) 
 * @see BaseDiscCache 
 * @see FileNameGenerator 
 * @since 1.0.0 
 */ 
public abstract class LimitedDiscCache extends BaseDiscCache { 
 
 private static final int INVALID_SIZE = -1; 
 
 //记录缓存文件的大小 
 private final AtomicInteger cacheSize; 
 //缓存文件的最大值 
 private final int sizeLimit; 
 private final Map<File, Long> lastUsageDates = Collections.synchronizedMap(new HashMap<File, Long>()); 
 
 /** 
  * @param cacheDir Directory for file caching. <b>Important:</b> Specify separate folder for cached files. It's 
  *     needed for right cache limit work. 
  * @param sizeLimit Cache limit value. If cache exceeds this limit then file with the most oldest last usage date 
  *     will be deleted. 
  */ 
 public LimitedDiscCache(File cacheDir, int sizeLimit) { 
  this(cacheDir, DefaultConfigurationFactory.createFileNameGenerator(), sizeLimit); 
 } 
 
 /** 
  * @param cacheDir   Directory for file caching. <b>Important:</b> Specify separate folder for cached files. It's 
  *       needed for right cache limit work. 
  * @param fileNameGenerator Name generator for cached files 
  * @param sizeLimit   Cache limit value. If cache exceeds this limit then file with the most oldest last usage date 
  *       will be deleted. 
  */ 
 public LimitedDiscCache(File cacheDir, FileNameGenerator fileNameGenerator, int sizeLimit) { 
  super(cacheDir, fileNameGenerator); 
  this.sizeLimit = sizeLimit; 
  cacheSize = new AtomicInteger(); 
  calculateCacheSizeAndFillUsageMap(); 
 } 
 
 /** 
  * 另开线程计算cacheDir里面文件的大小，并将文件和最后修改的毫秒数加入到Map中 
  */ 
 private void calculateCacheSizeAndFillUsageMap() { 
  new Thread(new Runnable() { 
   @Override 
   public void run() { 
    int size = 0; 
    File[] cachedFiles = cacheDir.listFiles(); 
    if (cachedFiles != null) { // rarely but it can happen, don't know why 
     for (File cachedFile : cachedFiles) { 
      //getSize()是一个抽象方法，子类自行实现getSize()的逻辑 
      size += getSize(cachedFile); 
      //将文件的最后修改时间加入到map中 
      lastUsageDates.put(cachedFile, cachedFile.lastModified()); 
     } 
     cacheSize.set(size); 
    } 
   } 
  }).start(); 
 } 
 
 /** 
  * 将文件添加到Map中，并计算缓存文件的大小是否超过了我们设置的最大缓存数 
  * 超过了就删除最先加入的那个文件 
  */ 
 @Override 
 public void put(String key, File file) { 
  //要加入文件的大小 
  int valueSize = getSize(file); 
   
  //获取当前缓存文件大小总数 
  int curCacheSize = cacheSize.get(); 
  //判断是否超过设定的最大缓存值 
  while (curCacheSize + valueSize > sizeLimit) { 
   int freedSize = removeNext(); 
   if (freedSize == INVALID_SIZE) break; // cache is empty (have nothing to delete) 
   curCacheSize = cacheSize.addAndGet(-freedSize); 
  } 
  cacheSize.addAndGet(valueSize); 
 
  Long currentTime = System.currentTimeMillis(); 
  file.setLastModified(currentTime); 
  lastUsageDates.put(file, currentTime); 
 } 
 
 /** 
  * 根据key生成文件 
  */ 
 @Override 
 public File get(String key) { 
  File file = super.get(key); 
 
  Long currentTime = System.currentTimeMillis(); 
  file.setLastModified(currentTime); 
  lastUsageDates.put(file, currentTime); 
 
  return file; 
 } 
 
 /** 
  * 硬盘缓存的清理 
  */ 
 @Override 
 public void clear() { 
  lastUsageDates.clear(); 
  cacheSize.set(0); 
  super.clear(); 
 } 
 
  
 /** 
  * 获取最早加入的缓存文件，并将其删除 
  */ 
 private int removeNext() { 
  if (lastUsageDates.isEmpty()) { 
   return INVALID_SIZE; 
  } 
  Long oldestUsage = null; 
  File mostLongUsedFile = null; 
   
  Set<Entry<File, Long>> entries = lastUsageDates.entrySet(); 
  synchronized (lastUsageDates) { 
   for (Entry<File, Long> entry : entries) { 
    if (mostLongUsedFile == null) { 
     mostLongUsedFile = entry.getKey(); 
     oldestUsage = entry.getValue(); 
    } else { 
     Long lastValueUsage = entry.getValue(); 
     if (lastValueUsage < oldestUsage) { 
      oldestUsage = lastValueUsage; 
      mostLongUsedFile = entry.getKey(); 
     } 
    } 
   } 
  } 
 
  int fileSize = 0; 
  if (mostLongUsedFile != null) { 
   if (mostLongUsedFile.exists()) { 
    fileSize = getSize(mostLongUsedFile); 
    if (mostLongUsedFile.delete()) { 
     lastUsageDates.remove(mostLongUsedFile); 
    } 
   } else { 
    lastUsageDates.remove(mostLongUsedFile); 
   } 
  } 
  return fileSize; 
 } 
 
 /** 
  * 抽象方法，获取文件大小 
  * @param file 
  * @return 
  */ 
 protected abstract int getSize(File file); 
} 

/** 
 * Creates default implementation of {@link DiskCache} depends on incoming parameters 
 */ 
public static DiskCache createDiskCache(Context context, FileNameGenerator diskCacheFileNameGenerator, 
  long diskCacheSize, int diskCacheFileCount) { 
 File reserveCacheDir = createReserveDiskCacheDir(context); 
 if (diskCacheSize > 0 || diskCacheFileCount > 0) { 
  File individualCacheDir = StorageUtils.getIndividualCacheDirectory(context); 
  LruDiscCache diskCache = new LruDiscCache(individualCacheDir, diskCacheFileNameGenerator, diskCacheSize, 
    diskCacheFileCount); 
  diskCache.setReserveCacheDir(reserveCacheDir); 
  return diskCache; 
 } else { 
  File cacheDir = StorageUtils.getCacheDirectory(context); 
  return new UnlimitedDiscCache(cacheDir, reserveCacheDir, diskCacheFileNameGenerator); 
 } 
} 

ImageView mImageView = (ImageView) findViewById(R.id.image); 
  String imageUrl = "https://lh6.googleusercontent.com/-55osAWw3x0Q/URquUtcFr5I/AAAAAAAAAbs/rWlj1RUKrYI/s1024/A%252520Photographer.jpg"; 
   
  //显示图片的配置 
  DisplayImageOptions options = new DisplayImageOptions.Builder() 
    .showImageOnLoading(R.drawable.ic_stub) 
    .showImageOnFail(R.drawable.ic_error) 
    .cacheInMemory(true) 
    .cacheOnDisk(true) 
    .bitmapConfig(Bitmap.Config.RGB_565) 
    .build(); 

public void displayImage(String uri, ImageView imageView, DisplayImageOptions options) { 
  displayImage(uri, new ImageViewAware(imageView), options, null, null); 
 } 

checkConfiguration(); 
  if (imageAware == null) { 
   throw new IllegalArgumentException(ERROR_WRONG_ARGUMENTS); 
  } 
  if (listener == null) { 
   listener = emptyListener; 
  } 
  if (options == null) { 
   options = configuration.defaultDisplayImageOptions; 
  } 
 
  if (TextUtils.isEmpty(uri)) { 
   engine.cancelDisplayTaskFor(imageAware); 
   listener.onLoadingStarted(uri, imageAware.getWrappedView()); 
   if (options.shouldShowImageForEmptyUri()) { 
    imageAware.setImageDrawable(options.getImageForEmptyUri(configuration.resources)); 
   } else { 
    imageAware.setImageDrawable(null); 
   } 
   listener.onLoadingComplete(uri, imageAware.getWrappedView(), null); 
   return; 
  } 

ImageSize targetSize = ImageSizeUtils.defineTargetSizeForView(imageAware, configuration.getMaxImageSize()); 
 String memoryCacheKey = MemoryCacheUtils.generateKey(uri, targetSize); 
 engine.prepareDisplayTaskFor(imageAware, memoryCacheKey); 
 
 listener.onLoadingStarted(uri, imageAware.getWrappedView()); 
 
 Bitmap bmp = configuration.memoryCache.get(memoryCacheKey); 
 if (bmp != null && !bmp.isRecycled()) { 
  L.d(LOG_LOAD_IMAGE_FROM_MEMORY_CACHE, memoryCacheKey); 
 
  if (options.shouldPostProcess()) { 
   ImageLoadingInfo imageLoadingInfo = new ImageLoadingInfo(uri, imageAware, targetSize, memoryCacheKey, 
     options, listener, progressListener, engine.getLockForUri(uri)); 
   ProcessAndDisplayImageTask displayTask = new ProcessAndDisplayImageTask(engine, bmp, imageLoadingInfo, 
     defineHandler(options)); 
   if (options.isSyncLoading()) { 
    displayTask.run(); 
   } else { 
    engine.submit(displayTask); 
   } 
  } else { 
   options.getDisplayer().display(bmp, imageAware, LoadedFrom.MEMORY_CACHE); 
   listener.onLoadingComplete(uri, imageAware.getWrappedView(), bmp); 
  } 
 } 

if (options.shouldShowImageOnLoading()) { 
    imageAware.setImageDrawable(options.getImageOnLoading(configuration.resources)); 
   } else if (options.isResetViewBeforeLoading()) { 
    imageAware.setImageDrawable(null); 
   } 
 
   ImageLoadingInfo imageLoadingInfo = new ImageLoadingInfo(uri, imageAware, targetSize, memoryCacheKey, 
     options, listener, progressListener, engine.getLockForUri(uri)); 
   LoadAndDisplayImageTask displayTask = new LoadAndDisplayImageTask(engine, imageLoadingInfo, 
     defineHandler(options)); 
   if (options.isSyncLoading()) { 
    displayTask.run(); 
   } else { 
    engine.submit(displayTask); 
   } 

if (waitIfPaused()) return; 
if (delayIfNeed()) return; 

waitIfPaused（）

private boolean waitIfPaused() { 
 AtomicBoolean pause = engine.getPause(); 
 if (pause.get()) { 
  synchronized (engine.getPauseLock()) { 
   if (pause.get()) { 
    L.d(LOG_WAITING_FOR_RESUME, memoryCacheKey); 
    try { 
     engine.getPauseLock().wait(); 
    } catch (InterruptedException e) { 
     L.e(LOG_TASK_INTERRUPTED, memoryCacheKey); 
     return true; 
    } 
    L.d(LOG_RESUME_AFTER_PAUSE, memoryCacheKey); 
   } 
  } 
 } 
 return isTaskNotActual(); 
} 

private boolean isTaskNotActual() { 
  return isViewCollected() || isViewReused(); 
 } 

ReentrantLock loadFromUriLock = imageLoadingInfo.loadFromUriLock; 
  L.d(LOG_START_DISPLAY_IMAGE_TASK, memoryCacheKey); 
  if (loadFromUriLock.isLocked()) { 
   L.d(LOG_WAITING_FOR_IMAGE_LOADED, memoryCacheKey); 
  } 
 
  loadFromUriLock.lock(); 
  Bitmap bmp; 
  try { 
   checkTaskNotActual(); 
 
   bmp = configuration.memoryCache.get(memoryCacheKey); 
   if (bmp == null || bmp.isRecycled()) { 
    bmp = tryLoadBitmap(); 
    if (bmp == null) return; // listener callback already was fired 
 
    checkTaskNotActual(); 
    checkTaskInterrupted(); 
 
    if (options.shouldPreProcess()) { 
     L.d(LOG_PREPROCESS_IMAGE, memoryCacheKey); 
     bmp = options.getPreProcessor().process(bmp); 
     if (bmp == null) { 
      L.e(ERROR_PRE_PROCESSOR_NULL, memoryCacheKey); 
     } 
    } 
 
    if (bmp != null && options.isCacheInMemory()) { 
     L.d(LOG_CACHE_IMAGE_IN_MEMORY, memoryCacheKey); 
     configuration.memoryCache.put(memoryCacheKey, bmp); 
    } 
   } else { 
    loadedFrom = LoadedFrom.MEMORY_CACHE; 
    L.d(LOG_GET_IMAGE_FROM_MEMORY_CACHE_AFTER_WAITING, memoryCacheKey); 
   } 
 
   if (bmp != null && options.shouldPostProcess()) { 
    L.d(LOG_POSTPROCESS_IMAGE, memoryCacheKey); 
    bmp = options.getPostProcessor().process(bmp); 
    if (bmp == null) { 
     L.e(ERROR_POST_PROCESSOR_NULL, memoryCacheKey); 
    } 
   } 
   checkTaskNotActual(); 
   checkTaskInterrupted(); 
  } catch (TaskCancelledException e) { 
   fireCancelEvent(); 
   return; 
  } finally { 
   loadFromUriLock.unlock(); 
  } 

ReentrantLock getLockForUri(String uri) { 
  ReentrantLock lock = uriLocks.get(uri); 
  if (lock == null) { 
   lock = new ReentrantLock(); 
   uriLocks.put(uri, lock); 
  } 
  return lock; 
 } 

File imageFile = configuration.diskCache.get(uri); 
   if (imageFile != null && imageFile.exists()) { 
    L.d(LOG_LOAD_IMAGE_FROM_DISK_CACHE, memoryCacheKey); 
    loadedFrom = LoadedFrom.DISC_CACHE; 
 
    checkTaskNotActual(); 
    bitmap = decodeImage(Scheme.FILE.wrap(imageFile.getAbsolutePath())); 
   } 

if (bitmap == null || bitmap.getWidth() <= 0 || bitmap.getHeight() <= 0) { 
   L.d(LOG_LOAD_IMAGE_FROM_NETWORK, memoryCacheKey); 
   loadedFrom = LoadedFrom.NETWORK; 
 
   String imageUriForDecoding = uri; 
   if (options.isCacheOnDisk() && tryCacheImageOnDisk()) { 
    imageFile = configuration.diskCache.get(uri); 
    if (imageFile != null) { 
     imageUriForDecoding = Scheme.FILE.wrap(imageFile.getAbsolutePath()); 
    } 
   } 
 
   checkTaskNotActual(); 
   bitmap = decodeImage(imageUriForDecoding); 
 
   if (bitmap == null || bitmap.getWidth() <= 0 || bitmap.getHeight() <= 0) { 
    fireFailEvent(FailType.DECODING_ERROR, null); 
   } 
  } 

private Bitmap decodeImage(String imageUri) throws IOException { 
 ViewScaleType viewScaleType = imageAware.getScaleType(); 
 ImageDecodingInfo decodingInfo = new ImageDecodingInfo(memoryCacheKey, imageUri, uri, targetSize, viewScaleType, 
   getDownloader(), options); 
 return decoder.decode(decodingInfo); 
} 
 
/** @return <b>true</b> - if image was downloaded successfully; <b>false</b> - otherwise */ 
private boolean tryCacheImageOnDisk() throws TaskCancelledException { 
 L.d(LOG_CACHE_IMAGE_ON_DISK, memoryCacheKey); 
 
 boolean loaded; 
 try { 
  loaded = downloadImage(); 
  if (loaded) { 
   int width = configuration.maxImageWidthForDiskCache; 
   int height = configuration.maxImageHeightForDiskCache; 
    
   if (width > 0 || height > 0) { 
    L.d(LOG_RESIZE_CACHED_IMAGE_FILE, memoryCacheKey); 
    resizeAndSaveImage(width, height); // TODO : process boolean result 
   } 
  } 
 } catch (IOException e) { 
  L.e(e); 
  loaded = false; 
 } 
 return loaded; 
} 
 
private boolean downloadImage() throws IOException { 
 InputStream is = getDownloader().getStream(uri, options.getExtraForDownloader()); 
 return configuration.diskCache.save(uri, is, this); 
} 

if (bmp == null) return; // listener callback already was fired 
 
    checkTaskNotActual(); 
    checkTaskInterrupted(); 
 
    if (options.shouldPreProcess()) { 
     L.d(LOG_PREPROCESS_IMAGE, memoryCacheKey); 
     bmp = options.getPreProcessor().process(bmp); 
     if (bmp == null) { 
      L.e(ERROR_PRE_PROCESSOR_NULL, memoryCacheKey); 
     } 
    } 
 
    if (bmp != null && options.isCacheInMemory()) { 
     L.d(LOG_CACHE_IMAGE_IN_MEMORY, memoryCacheKey); 
     configuration.memoryCache.put(memoryCacheKey, bmp); 
    } 

DisplayBitmapTask displayBitmapTask = new DisplayBitmapTask(bmp, imageLoadingInfo, engine, loadedFrom); 
  runTask(displayBitmapTask, syncLoading, handler, engine); 

@Override 
 public void run() { 
  if (imageAware.isCollected()) { 
   L.d(LOG_TASK_CANCELLED_IMAGEAWARE_COLLECTED, memoryCacheKey); 
   listener.onLoadingCancelled(imageUri, imageAware.getWrappedView()); 
  } else if (isViewWasReused()) { 
   L.d(LOG_TASK_CANCELLED_IMAGEAWARE_REUSED, memoryCacheKey); 
   listener.onLoadingCancelled(imageUri, imageAware.getWrappedView()); 
  } else { 
   L.d(LOG_DISPLAY_IMAGE_IN_IMAGEAWARE, loadedFrom, memoryCacheKey); 
   displayer.display(bitmap, imageAware, loadedFrom); 
   engine.cancelDisplayTaskFor(imageAware); 
   listener.onLoadingComplete(imageUri, imageAware.getWrappedView(), bitmap); 
  } 
 }