Android 开源框架Universal-Image-Loader完全解析（三）

一、介绍

 Android-Universal-Image-Loader是一个开源的UI组件程序，该项目的目的是提供一个可重复使用的仪器为异步图像加载，缓存和显示。所以，如果你的程序里需要这个功能的话，那么不妨试试它。因为已经封装好了一些类和方法。我们 可以直接拿来用了。而不用重复去写了。其实，写一个这方面的程序还是比较麻烦的，要考虑多线程缓存，内存溢出等很多方面。

二、具体使用

一个好的类库的重要特征就是可配置性强。我们先简单使用Android-Universal-Image-Loader，一般情况下使用默认配置就可以了。

下面的实例利用Android-Universal-Image-Loader将网络图片加载到图片墙中。

public class BaseActivity extends Activity { 2     ImageLoader imageLoader; 3     @Override 4     protected void onCreate(Bundle savedInstanceState) { 5           // Create global configuration and initialize ImageLoader with this configuration 6         ImageLoaderConfiguration config = new ImageLoaderConfiguration.Builder(getApplicationContext()) 7             .build(); 8         ImageLoader.getInstance().init(config); 9         super.onCreate(savedInstanceState);10     }11 }  

public class MainActivity extends BaseActivity {  2   3     @Override  4     protected void onCreate(Bundle savedInstanceState) {  5         super.onCreate(savedInstanceState);  6         setContentView(R.layout.activity_main);  7     8         ImageLoader imageLoader = ImageLoader.getInstance();  9  10         GridView gridView = (GridView) this.findViewById(R.id.grdvImageWall); 11         gridView.setAdapter(new PhotoWallAdapter(Constants.IMAGES)); 12     } 13  14     static class ViewHolder { 15         ImageView imageView; 16         ProgressBar progressBar; 17     } 18  19     public class PhotoWallAdapter extends BaseAdapter { 20         String[] imageUrls; 21         ImageLoader imageLoad; 22         DisplayImageOptions options; 23         LinearLayout gridViewItem; 24  25         public PhotoWallAdapter(String[] imageUrls) { 26             assert imageUrls != null; 27             this.imageUrls = imageUrls; 28  29             options = new DisplayImageOptions.Builder() 30                     .showImageOnLoading(R.drawable.ic_stub) // resource or 31                                                             // drawable 32                     .showImageForEmptyUri(R.drawable.ic_empty) // resource or 33                                                                 // drawable 34                     .showImageOnFail(R.drawable.ic_error) // resource or 35                                                             // drawable 36                     .resetViewBeforeLoading(false) // default 37                     .delayBeforeLoading(1000).cacheInMemory(false) // default 38                     .cacheOnDisk(false) // default 39                     .considerExifParams(false) // default 40                     .imageScaleType(ImageScaleType.IN_SAMPLE_POWER_OF_2) // default 41                     .bitmapConfig(Bitmap.Config.ARGB_8888) // default 42                     .displayer(new SimpleBitmapDisplayer()) // default 43                     .handler(new Handler()) // default 44                     .build(); 45             this.imageLoad = ImageLoader.getInstance(); 46  47         } 48  49         @Override 50         public int getCount() { 51             return this.imageUrls.length; 52         } 53  54         @Override 55         public Object getItem(int position) { 56             if (position <= 0 || position >= this.imageUrls.length) { 57                 throw new IllegalArgumentException( 58                         "position<=0||position>=this.imageUrls.length"); 59             } 60             return this.imageUrls[position]; 61         } 62  63         @Override 64         public long getItemId(int position) { 65             return position; 66         } 67  68         @Override 69         public View getView(int position, View convertView, ViewGroup parent) { 70             // 判断这个image是否已经在缓存当中，如果没有就下载 71             final ViewHolder holder; 72             if (convertView == null) { 73                 holder = new ViewHolder(); 74                 gridViewItem = (LinearLayout) getLayoutInflater().inflate( 75                         R.layout.image_wall_item, null); 76                 holder.imageView = (ImageView) gridViewItem 77                         .findViewById(R.id.item_image); 78                 holder.progressBar = (ProgressBar) gridViewItem 79                         .findViewById(R.id.item_process); 80                 gridViewItem.setTag(holder); 81                 convertView = gridViewItem; 82             } else { 83                 holder = (ViewHolder) gridViewItem.getTag(); 84             } 85             this.imageLoad.displayImage(this.imageUrls[position], 86                     holder.imageView, options, 87                     new SimpleImageLoadingListener() { 88  89                         @Override 90                         public void onLoadingStarted(String imageUri, View view) { 91                             holder.progressBar.setProgress(0); 92                             holder.progressBar.setVisibility(View.VISIBLE); 93                         } 94  95                         @Override 96                         public void onLoadingFailed(String imageUri, View view, 97                                 FailReason failReason) { 98                             holder.progressBar.setVisibility(View.GONE); 99                         }100 101                         @Override102                         public void onLoadingComplete(String imageUri,103                                 View view, Bitmap loadedImage) {104                             holder.progressBar.setVisibility(View.GONE);105                         }106 107                     }, new ImageLoadingProgressListener() {108 109                         @Override110                         public void onProgressUpdate(String imageUri,111                                 View view, int current, int total) {112                             holder.progressBar.setProgress(Math.round(100.0f113                                     * current / total));114                         }115                     }); // 通过URL判断图片是否已经下载116             return convertView;117         }118 119     }120 }

里面主要的对象都用        突出显示了。

三者的关系

ImageLoaderConfiguration是针对图片缓存的全局配置，主要有线程类、缓存大小、磁盘大小、图片下载与解析、日志方面的配置。

ImageLoader是具体下载图片，缓存图片，显示图片的具体执行类，它有两个具体的方法displayImage(...)、loadImage(...)，但是其实最终他们的实现都是displayImage(...)。

DisplayImageOptions用于指导每一个Imageloader根据网络图片的状态（空白、下载错误、正在下载）显示对应的图片，是否将缓存加载到磁盘上，下载完后对图片进行怎么样的处理。

从三者的协作关系上看，他们有点像厨房规定、厨师、客户个人口味之间的关系。ImageLoaderConfiguration就像是厨房里面的规定，每一个厨师要怎么着装，要怎么保持厨房的干净，这是针对每一个厨师都适用的规定，而且不允许个性化改变。ImageLoader就像是具体做菜的厨师，负责具体菜谱的制作。DisplayImageOptions就像每个客户的偏好，根据客户是重口味还是清淡，每一个imageLoader根据DisplayImageOptions的要求具体执行。

 

ImageLoaderConfiguration

在上面的示例代码中，我们使用ImageLoaderConfiguration的默认配置，下面给出ImageLoaderConfiguration比较详尽的配置，从下面的配置中，可以看出ImageLoaderConfiguration的配置主要是全局性的配置，主要有线程类、缓存大小、磁盘大小、图片下载与解析、日志方面的配置。

ImageLoaderConfiguration config = new ImageLoaderConfiguration.Builder(context)        .memoryCacheExtraOptions(480, 800) // default = device screen dimensions        .diskCacheExtraOptions(480, 800, 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();

ImageLoaderConfiguration的主要职责就是记录相关的配置，它的内部其实就是一些字段的集合（如下面的源代码）。它有一个builder的内部类，这个类中的字段跟ImageLoaderConfiguration中的字段完全一致，它有一些默认值，通过修改builder可以配置ImageLoaderConfiguration。

/*******************************************************************************  2  * Copyright 2011-2013 Sergey Tarasevich  3  *  4  * Licensed under the Apache License, Version 2.0 (the "License");  5  * you may not use this file except in compliance with the License.  6  * You may obtain a copy of the License at  7  *  8  * http://www.apache.org/licenses/LICENSE-2.0  9  * 10  * Unless required by applicable law or agreed to in writing, software 11  * distributed under the License is distributed on an "AS IS" BASIS, 12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13  * See the License for the specific language governing permissions and 14  * limitations under the License. 15  *******************************************************************************/ 16 package com.nostra13.universalimageloader.core; 17  18 import android.content.Context; 19 import android.content.res.Resources; 20 import android.util.DisplayMetrics; 21 import com.nostra13.universalimageloader.cache.disc.DiskCache; 22 import com.nostra13.universalimageloader.cache.disc.naming.FileNameGenerator; 23 import com.nostra13.universalimageloader.cache.memory.MemoryCache; 24 import com.nostra13.universalimageloader.cache.memory.impl.FuzzyKeyMemoryCache; 25 import com.nostra13.universalimageloader.core.assist.FlushedInputStream; 26 import com.nostra13.universalimageloader.core.assist.ImageSize; 27 import com.nostra13.universalimageloader.core.assist.QueueProcessingType; 28 import com.nostra13.universalimageloader.core.decode.ImageDecoder; 29 import com.nostra13.universalimageloader.core.download.ImageDownloader; 30 import com.nostra13.universalimageloader.core.process.BitmapProcessor; 31 import com.nostra13.universalimageloader.utils.L; 32 import com.nostra13.universalimageloader.utils.MemoryCacheUtils; 33  34 import java.io.IOException; 35 import java.io.InputStream; 36 import java.util.concurrent.Executor; 37  38 /** 39  * Presents configuration for {@link ImageLoader} 40  * 41  * @author Sergey Tarasevich (nostra13[at]gmail[dot]com) 42  * @see ImageLoader 43  * @see MemoryCache 44  * @see DiskCache 45  * @see DisplayImageOptions 46  * @see ImageDownloader 47  * @see FileNameGenerator 48  * @since 1.0.0 49  */ 50 public final class ImageLoaderConfiguration { 51  52     final Resources resources; 53  54     final int maxImageWidthForMemoryCache; 55     final int maxImageHeightForMemoryCache; 56     final int maxImageWidthForDiskCache; 57     final int maxImageHeightForDiskCache; 58     final BitmapProcessor processorForDiskCache; 59  60     final Executor taskExecutor; 61     final Executor taskExecutorForCachedImages; 62     final boolean customExecutor; 63     final boolean customExecutorForCachedImages; 64  65     final int threadPoolSize; 66     final int threadPriority; 67     final QueueProcessingType tasksProcessingType; 68  69     final MemoryCache memoryCache; 70     final DiskCache diskCache; 71     final ImageDownloader downloader; 72     final ImageDecoder decoder; 73     final DisplayImageOptions defaultDisplayImageOptions; 74  75     final ImageDownloader networkDeniedDownloader; 76     final ImageDownloader slowNetworkDownloader; 77  78     private ImageLoaderConfiguration(final Builder builder) { 79         resources = builder.context.getResources(); 80         maxImageWidthForMemoryCache = builder.maxImageWidthForMemoryCache; 81         maxImageHeightForMemoryCache = builder.maxImageHeightForMemoryCache; 82         maxImageWidthForDiskCache = builder.maxImageWidthForDiskCache; 83         maxImageHeightForDiskCache = builder.maxImageHeightForDiskCache; 84         processorForDiskCache = builder.processorForDiskCache; 85         taskExecutor = builder.taskExecutor; 86         taskExecutorForCachedImages = builder.taskExecutorForCachedImages; 87         threadPoolSize = builder.threadPoolSize; 88         threadPriority = builder.threadPriority; 89         tasksProcessingType = builder.tasksProcessingType; 90         diskCache = builder.diskCache; 91         memoryCache = builder.memoryCache; 92         defaultDisplayImageOptions = builder.defaultDisplayImageOptions; 93         downloader = builder.downloader; 94         decoder = builder.decoder; 95  96         customExecutor = builder.customExecutor; 97         customExecutorForCachedImages = builder.customExecutorForCachedImages; 98  99         networkDeniedDownloader = new NetworkDeniedImageDownloader(downloader);100         slowNetworkDownloader = new SlowNetworkImageDownloader(downloader);101 102         L.writeDebugLogs(builder.writeLogs);103     }104 105     /**106      * Creates default configuration for {@link ImageLoader} <br />107      * <b>Default values:</b>108      * <ul>109      * <li>maxImageWidthForMemoryCache = device's screen width</li>110      * <li>maxImageHeightForMemoryCache = device's screen height</li>111      * <li>maxImageWidthForDikcCache = unlimited</li>112      * <li>maxImageHeightForDiskCache = unlimited</li>113      * <li>threadPoolSize = {@link Builder#DEFAULT_THREAD_POOL_SIZE this}</li>114      * <li>threadPriority = {@link Builder#DEFAULT_THREAD_PRIORITY this}</li>115      * <li>allow to cache different sizes of image in memory</li>116      * <li>memoryCache = {@link DefaultConfigurationFactory#createMemoryCache(int)}</li>117      * <li>diskCache = {@link com.nostra13.universalimageloader.cache.disc.impl.UnlimitedDiscCache}</li>118      * <li>imageDownloader = {@link DefaultConfigurationFactory#createImageDownloader(Context)}</li>119      * <li>imageDecoder = {@link DefaultConfigurationFactory#createImageDecoder(boolean)}</li>120      * <li>diskCacheFileNameGenerator = {@link DefaultConfigurationFactory#createFileNameGenerator()}</li>121      * <li>defaultDisplayImageOptions = {@link DisplayImageOptions#createSimple() Simple options}</li>122      * <li>tasksProcessingOrder = {@link QueueProcessingType#FIFO}</li>123      * <li>detailed logging disabled</li>124      * </ul>125      */126     public static ImageLoaderConfiguration createDefault(Context context) {127         return new Builder(context).build();128     }129 130     ImageSize getMaxImageSize() {131         DisplayMetrics displayMetrics = resources.getDisplayMetrics();132 133         int width = maxImageWidthForMemoryCache;134         if (width <= 0) {135             width = displayMetrics.widthPixels;136         }137         int height = maxImageHeightForMemoryCache;138         if (height <= 0) {139             height = displayMetrics.heightPixels;140         }141         return new ImageSize(width, height);142     }143 144     /**145      * Builder for {@link ImageLoaderConfiguration}146      *147      * @author Sergey Tarasevich (nostra13[at]gmail[dot]com)148      */149     public static class Builder {150 151         private static final String WARNING_OVERLAP_DISK_CACHE_PARAMS = "diskCache(), diskCacheSize() and diskCacheFileCount calls overlap each other";152         private static final String WARNING_OVERLAP_DISK_CACHE_NAME_GENERATOR = "diskCache() and diskCacheFileNameGenerator() calls overlap each other";153         private static final String WARNING_OVERLAP_MEMORY_CACHE = "memoryCache() and memoryCacheSize() calls overlap each other";154         private static final String WARNING_OVERLAP_EXECUTOR = "threadPoolSize(), threadPriority() and tasksProcessingOrder() calls "155                 + "can overlap taskExecutor() and taskExecutorForCachedImages() calls.";156 157         /** {@value} */158         public static final int DEFAULT_THREAD_POOL_SIZE = 3;159         /** {@value} */160         public static final int DEFAULT_THREAD_PRIORITY = Thread.NORM_PRIORITY - 1;161         /** {@value} */162         public static final QueueProcessingType DEFAULT_TASK_PROCESSING_TYPE = QueueProcessingType.FIFO;163 164         private Context context;165 166         private int maxImageWidthForMemoryCache = 0;167         private int maxImageHeightForMemoryCache = 0;168         private int maxImageWidthForDiskCache = 0;169         private int maxImageHeightForDiskCache = 0;170         private BitmapProcessor processorForDiskCache = null;171 172         private Executor taskExecutor = null;173         private Executor taskExecutorForCachedImages = null;174         private boolean customExecutor = false;175         private boolean customExecutorForCachedImages = false;176 177         private int threadPoolSize = DEFAULT_THREAD_POOL_SIZE;178         private int threadPriority = DEFAULT_THREAD_PRIORITY;179         private boolean denyCacheImageMultipleSizesInMemory = false;180         private QueueProcessingType tasksProcessingType = DEFAULT_TASK_PROCESSING_TYPE;181 182         private int memoryCacheSize = 0;183         private long diskCacheSize = 0;184         private int diskCacheFileCount = 0;185 186         private MemoryCache memoryCache = null;187         private DiskCache diskCache = null;188         private FileNameGenerator diskCacheFileNameGenerator = null;189         private ImageDownloader downloader = null;190         private ImageDecoder decoder;191         private DisplayImageOptions defaultDisplayImageOptions = null;192 193         private boolean writeLogs = false;194 195         public Builder(Context context) {196             this.context = context.getApplicationContext();197         }198 199         /**200          * Sets options for memory cache201          *202          * @param maxImageWidthForMemoryCache  Maximum image width which will be used for memory saving during decoding203          *                                     an image to {@link android.graphics.Bitmap Bitmap}. <b>Default value - device's screen width</b>204          * @param maxImageHeightForMemoryCache Maximum image height which will be used for memory saving during decoding205          *                                     an image to {@link android.graphics.Bitmap Bitmap}. <b>Default value</b> - device's screen height206          */207         public Builder memoryCacheExtraOptions(int maxImageWidthForMemoryCache, int maxImageHeightForMemoryCache) {208             this.maxImageWidthForMemoryCache = maxImageWidthForMemoryCache;209             this.maxImageHeightForMemoryCache = maxImageHeightForMemoryCache;210             return this;211         }212 213         /**214          * @deprecated Use215          * {@link #diskCacheExtraOptions(int, int, com.nostra13.universalimageloader.core.process.BitmapProcessor)}216          * instead217          */218         @Deprecated219         public Builder discCacheExtraOptions(int maxImageWidthForDiskCache, int maxImageHeightForDiskCache,220                 BitmapProcessor processorForDiskCache) {221             return diskCacheExtraOptions(maxImageWidthForDiskCache, maxImageHeightForDiskCache, processorForDiskCache);222         }223 224         /**225          * Sets options for resizing/compressing of downloaded images before saving to disk cache.<br />226          * <b>NOTE: Use this option only when you have appropriate needs. It can make ImageLoader slower.</b>227          *228          * @param maxImageWidthForDiskCache  Maximum width of downloaded images for saving at disk cache229          * @param maxImageHeightForDiskCache Maximum height of downloaded images for saving at disk cache230          * @param processorForDiskCache      null-ok; {@linkplain BitmapProcessor Bitmap processor} which process images before saving them in disc cache231          */232         public Builder diskCacheExtraOptions(int maxImageWidthForDiskCache, int maxImageHeightForDiskCache,233                 BitmapProcessor processorForDiskCache) {234             this.maxImageWidthForDiskCache = maxImageWidthForDiskCache;235             this.maxImageHeightForDiskCache = maxImageHeightForDiskCache;236             this.processorForDiskCache = processorForDiskCache;237             return this;238         }239 240         /**241          * Sets custom {@linkplain Executor executor} for tasks of loading and displaying images.<br />242          * <br />243          * <b>NOTE:</b> If you set custom executor then following configuration options will not be considered for this244          * executor:245          * <ul>246          * <li>{@link #threadPoolSize(int)}</li>247          * <li>{@link #threadPriority(int)}</li>248          * <li>{@link #tasksProcessingOrder(QueueProcessingType)}</li>249          * </ul>250          *251          * @see #taskExecutorForCachedImages(Executor)252          */253         public Builder taskExecutor(Executor executor) {254             if (threadPoolSize != DEFAULT_THREAD_POOL_SIZE || threadPriority != DEFAULT_THREAD_PRIORITY || tasksProcessingType != DEFAULT_TASK_PROCESSING_TYPE) {255                 L.w(WARNING_OVERLAP_EXECUTOR);256             }257 258             this.taskExecutor = executor;259             return this;260         }261 262         /**263          * Sets custom {@linkplain Executor executor} for tasks of displaying <b>cached on disk</b> images (these tasks264          * are executed quickly so UIL prefer to use separate executor for them).<br />265          * <br />266          * If you set the same executor for {@linkplain #taskExecutor(Executor) general tasks} and267          * tasks about cached images (this method) then these tasks will be in the268          * same thread pool. So short-lived tasks can wait a long time for their turn.<br />269          * <br />270          * <b>NOTE:</b> If you set custom executor then following configuration options will not be considered for this271          * executor:272          * <ul>273          * <li>{@link #threadPoolSize(int)}</li>274          * <li>{@link #threadPriority(int)}</li>275          * <li>{@link #tasksProcessingOrder(QueueProcessingType)}</li>276          * </ul>277          *278          * @see #taskExecutor(Executor)279          */280         public Builder taskExecutorForCachedImages(Executor executorForCachedImages) {281             if (threadPoolSize != DEFAULT_THREAD_POOL_SIZE || threadPriority != DEFAULT_THREAD_PRIORITY || tasksProcessingType != DEFAULT_TASK_PROCESSING_TYPE) {282                 L.w(WARNING_OVERLAP_EXECUTOR);283             }284 285             this.taskExecutorForCachedImages = executorForCachedImages;286             return this;287         }288 289         /**290          * Sets thread pool size for image display tasks.<br />291          * Default value - {@link #DEFAULT_THREAD_POOL_SIZE this}292          */293         public Builder threadPoolSize(int threadPoolSize) {294             if (taskExecutor != null || taskExecutorForCachedImages != null) {295                 L.w(WARNING_OVERLAP_EXECUTOR);296             }297 298             this.threadPoolSize = threadPoolSize;299             return this;300         }301 302         /**303          * Sets the priority for image loading threads. Should be <b>NOT</b> greater than {@link Thread#MAX_PRIORITY} or304          * less than {@link Thread#MIN_PRIORITY}<br />305          * Default value - {@link #DEFAULT_THREAD_PRIORITY this}306          */307         public Builder threadPriority(int threadPriority) {308             if (taskExecutor != null || taskExecutorForCachedImages != null) {309                 L.w(WARNING_OVERLAP_EXECUTOR);310             }311 312             if (threadPriority < Thread.MIN_PRIORITY) {313                 this.threadPriority = Thread.MIN_PRIORITY;314             } else {315                 if (threadPriority > Thread.MAX_PRIORITY) {316                     this.threadPriority = Thread.MAX_PRIORITY;317                 } else {318                     this.threadPriority = threadPriority;319                 }320             }321             return this;322         }323 324         /**325          * When you display an image in a small {@link android.widget.ImageView ImageView} and later you try to display326          * this image (from identical URI) in a larger {@link android.widget.ImageView ImageView} so decoded image of327          * bigger size will be cached in memory as a previous decoded image of smaller size.<br />328          * So <b>the default behavior is to allow to cache multiple sizes of one image in memory</b>. You can329          * <b>deny</b> it by calling <b>this</b> method: so when some image will be cached in memory then previous330          * cached size of this image (if it exists) will be removed from memory cache before.331          */332         public Builder denyCacheImageMultipleSizesInMemory() {333             this.denyCacheImageMultipleSizesInMemory = true;334             return this;335         }336 337         /**338          * Sets type of queue processing for tasks for loading and displaying images.<br />339          * Default value - {@link QueueProcessingType#FIFO}340          */341         public Builder tasksProcessingOrder(QueueProcessingType tasksProcessingType) {342             if (taskExecutor != null || taskExecutorForCachedImages != null) {343                 L.w(WARNING_OVERLAP_EXECUTOR);344             }345 346             this.tasksProcessingType = tasksProcessingType;347             return this;348         }349 350         /**351          * Sets maximum memory cache size for {@link android.graphics.Bitmap bitmaps} (in bytes).<br />352          * Default value - 1/8 of available app memory.<br />353          * <b>NOTE:</b> If you use this method then354          * {@link com.nostra13.universalimageloader.cache.memory.impl.LruMemoryCache LruMemoryCache} will be used as355          * memory cache. You can use {@link #memoryCache(MemoryCache)} method to set your own implementation of356          * {@link MemoryCache}.357          */358         public Builder memoryCacheSize(int memoryCacheSize) {359             if (memoryCacheSize <= 0) throw new IllegalArgumentException("memoryCacheSize must be a positive number");360 361             if (memoryCache != null) {362                 L.w(WARNING_OVERLAP_MEMORY_CACHE);363             }364 365             this.memoryCacheSize = memoryCacheSize;366             return this;367         }368 369         /**370          * Sets maximum memory cache size (in percent of available app memory) for {@link android.graphics.Bitmap371          * bitmaps}.<br />372          * Default value - 1/8 of available app memory.<br />373          * <b>NOTE:</b> If you use this method then374          * {@link com.nostra13.universalimageloader.cache.memory.impl.LruMemoryCache LruMemoryCache} will be used as375          * memory cache. You can use {@link #memoryCache(MemoryCache)} method to set your own implementation of376          * {@link MemoryCache}.377          */378         public Builder memoryCacheSizePercentage(int availableMemoryPercent) {379             if (availableMemoryPercent <= 0 || availableMemoryPercent >= 100) {380                 throw new IllegalArgumentException("availableMemoryPercent must be in range (0 < % < 100)");381             }382 383             if (memoryCache != null) {384                 L.w(WARNING_OVERLAP_MEMORY_CACHE);385             }386 387             long availableMemory = Runtime.getRuntime().maxMemory();388             memoryCacheSize = (int) (availableMemory * (availableMemoryPercent / 100f));389             return this;390         }391 392         /**393          * Sets memory cache for {@link android.graphics.Bitmap bitmaps}.<br />394          * Default value - {@link com.nostra13.universalimageloader.cache.memory.impl.LruMemoryCache LruMemoryCache}395          * with limited memory cache size (size = 1/8 of available app memory)<br />396          * <br />397          * <b>NOTE:</b> If you set custom memory cache then following configuration option will not be considered:398          * <ul>399          * <li>{@link #memoryCacheSize(int)}</li>400          * </ul>401          */402         public Builder memoryCache(MemoryCache memoryCache) {403             if (memoryCacheSize != 0) {404                 L.w(WARNING_OVERLAP_MEMORY_CACHE);405             }406 407             this.memoryCache = memoryCache;408             return this;409         }410 411         /** @deprecated Use {@link #diskCacheSize(int)} instead */412         @Deprecated413         public Builder discCacheSize(int maxCacheSize) {414             return diskCacheSize(maxCacheSize);415         }416 417         /**418          * Sets maximum disk cache size for images (in bytes).<br />419          * By default: disk cache is unlimited.<br />420          * <b>NOTE:</b> If you use this method then421          * {@link com.nostra13.universalimageloader.cache.disc.impl.ext.LruDiscCache LruDiscCache}422          * will be used as disk cache. You can use {@link #diskCache(DiskCache)} method for introduction your own423          * implementation of {@link DiskCache}424          */425         public Builder diskCacheSize(int maxCacheSize) {426             if (maxCacheSize <= 0) throw new IllegalArgumentException("maxCacheSize must be a positive number");427 428             if (diskCache != null) {429                 L.w(WARNING_OVERLAP_DISK_CACHE_PARAMS);430             }431 432             this.diskCacheSize = maxCacheSize;433             return this;434         }435 436         /** @deprecated Use {@link #diskCacheFileCount(int)} instead */437         @Deprecated438         public Builder discCacheFileCount(int maxFileCount) {439             return diskCacheFileCount(maxFileCount);440         }441 442         /**443          * Sets maximum file count in disk cache directory.<br />444          * By default: disk cache is unlimited.<br />445          * <b>NOTE:</b> If you use this method then446          * {@link com.nostra13.universalimageloader.cache.disc.impl.ext.LruDiscCache LruDiscCache}447          * will be used as disk cache. You can use {@link #diskCache(DiskCache)} method for introduction your own448          * implementation of {@link DiskCache}449          */450         public Builder diskCacheFileCount(int maxFileCount) {451             if (maxFileCount <= 0) throw new IllegalArgumentException("maxFileCount must be a positive number");452 453             if (diskCache != null) {454                 L.w(WARNING_OVERLAP_DISK_CACHE_PARAMS);455             }456 457             this.diskCacheFileCount = maxFileCount;458             return this;459         }460 461         /** @deprecated Use {@link #diskCacheFileNameGenerator(com.nostra13.universalimageloader.cache.disc.naming.FileNameGenerator)} */462         @Deprecated463         public Builder discCacheFileNameGenerator(FileNameGenerator fileNameGenerator) {464             return diskCacheFileNameGenerator(fileNameGenerator);465         }466 467         /**468          * Sets name generator for files cached in disk cache.<br />469          * Default value -470          * {@link com.nostra13.universalimageloader.core.DefaultConfigurationFactory#createFileNameGenerator()471          * DefaultConfigurationFactory.createFileNameGenerator()}472          */473         public Builder diskCacheFileNameGenerator(FileNameGenerator fileNameGenerator) {474             if (diskCache != null) {475                 L.w(WARNING_OVERLAP_DISK_CACHE_NAME_GENERATOR);476             }477 478             this.diskCacheFileNameGenerator = fileNameGenerator;479             return this;480         }481 482         /** @deprecated Use {@link #diskCache(com.nostra13.universalimageloader.cache.disc.DiskCache)} */483         @Deprecated484         public Builder discCache(DiskCache diskCache) {485             return diskCache(diskCache);486         }487 488         /**489          * Sets disk cache for images.<br />490          * Default value - {@link com.nostra13.universalimageloader.cache.disc.impl.UnlimitedDiscCache491          * BaseDiscCache}. Cache directory is defined by492          * {@link com.nostra13.universalimageloader.utils.StorageUtils#getCacheDirectory(Context)493          * StorageUtils.getCacheDirectory(Context)}.<br />494          * <br />495          * <b>NOTE:</b> If you set custom disk cache then following configuration option will not be considered:496          * <ul>497          * <li>{@link #diskCacheSize(int)}</li>498          * <li>{@link #diskCacheFileCount(int)}</li>499          * <li>{@link #diskCacheFileNameGenerator(FileNameGenerator)}</li>500          * </ul>501          */502         public Builder diskCache(DiskCache diskCache) {503             if (diskCacheSize > 0 || diskCacheFileCount > 0) {504                 L.w(WARNING_OVERLAP_DISK_CACHE_PARAMS);505             }506             if (diskCacheFileNameGenerator != null) {507                 L.w(WARNING_OVERLAP_DISK_CACHE_NAME_GENERATOR);508             }509 510             this.diskCache = diskCache;511             return this;512         }513 514         /**515          * Sets utility which will be responsible for downloading of image.<br />516          * Default value -517          * {@link com.nostra13.universalimageloader.core.DefaultConfigurationFactory#createImageDownloader(Context)518          * DefaultConfigurationFactory.createImageDownloader()}519          */520         public Builder imageDownloader(ImageDownloader imageDownloader) {521             this.downloader = imageDownloader;522             return this;523         }524 525         /**526          * Sets utility which will be responsible for decoding of image stream.<br />527          * Default value -528          * {@link com.nostra13.universalimageloader.core.DefaultConfigurationFactory#createImageDecoder(boolean)529          * DefaultConfigurationFactory.createImageDecoder()}530          */531         public Builder imageDecoder(ImageDecoder imageDecoder) {532             this.decoder = imageDecoder;533             return this;534         }535 536         /**537          * Sets default {@linkplain DisplayImageOptions display image options} for image displaying. These options will538          * be used for every {@linkplain ImageLoader#displayImage(String, android.widget.ImageView) image display call}539          * without passing custom {@linkplain DisplayImageOptions options}<br />540          * Default value - {@link DisplayImageOptions#createSimple() Simple options}541          */542         public Builder defaultDisplayImageOptions(DisplayImageOptions defaultDisplayImageOptions) {543             this.defaultDisplayImageOptions = defaultDisplayImageOptions;544             return this;545         }546 547         /**548          * Enables detail logging of {@link ImageLoader} work. To prevent detail logs don't call this method.549          * Consider {@link com.nostra13.universalimageloader.utils.L#disableLogging()} to disable550          * ImageLoader logging completely (even error logs)551          */552         public Builder writeDebugLogs() {553             this.writeLogs = true;554             return this;555         }556 557         /** Builds configured {@link ImageLoaderConfiguration} object */558         public ImageLoaderConfiguration build() {559             initEmptyFieldsWithDefaultValues();560             return new ImageLoaderConfiguration(this);561         }562 563         private void initEmptyFieldsWithDefaultValues() {564             if (taskExecutor == null) {565                 taskExecutor = DefaultConfigurationFactory566                         .createExecutor(threadPoolSize, threadPriority, tasksProcessingType);567             } else {568                 customExecutor = true;569             }570             if (taskExecutorForCachedImages == null) {571                 taskExecutorForCachedImages = DefaultConfigurationFactory572                         .createExecutor(threadPoolSize, threadPriority, tasksProcessingType);573             } else {574                 customExecutorForCachedImages = true;575             }576             if (diskCache == null) {577                 if (diskCacheFileNameGenerator == null) {578                     diskCacheFileNameGenerator = DefaultConfigurationFactory.createFileNameGenerator();579                 }580                 diskCache = DefaultConfigurationFactory581                         .createDiskCache(context, diskCacheFileNameGenerator, diskCacheSize, diskCacheFileCount);582             }583             if (memoryCache == null) {584                 memoryCache = DefaultConfigurationFactory.createMemoryCache(memoryCacheSize);585             }586             if (denyCacheImageMultipleSizesInMemory) {587                 memoryCache = new FuzzyKeyMemoryCache(memoryCache, MemoryCacheUtils.createFuzzyKeyComparator());588             }589             if (downloader == null) {590                 downloader = DefaultConfigurationFactory.createImageDownloader(context);591             }592             if (decoder == null) {593                 decoder = DefaultConfigurationFactory.createImageDecoder(writeLogs);594             }595             if (defaultDisplayImageOptions == null) {596                 defaultDisplayImageOptions = DisplayImageOptions.createSimple();597             }598         }599     }600 601     /**602      * Decorator. Prevents downloads from network (throws {@link IllegalStateException exception}).<br />603      * In most cases this downloader shouldn't be used directly.604      *605      * @author Sergey Tarasevich (nostra13[at]gmail[dot]com)606      * @since 1.8.0607      */608     private static class NetworkDeniedImageDownloader implements ImageDownloader {609 610         private final ImageDownloader wrappedDownloader;611 612         public NetworkDeniedImageDownloader(ImageDownloader wrappedDownloader) {613             this.wrappedDownloader = wrappedDownloader;614         }615 616         @Override617         public InputStream getStream(String imageUri, Object extra) throws IOException {618             switch (Scheme.ofUri(imageUri)) {619                 case HTTP:620                 case HTTPS:621                     throw new IllegalStateException();622                 default:623                     return wrappedDownloader.getStream(imageUri, extra);624             }625         }626     }627 628     /**629      * Decorator. Handles <a href="http://code.google.com/p/android/issues/detail?id=6066">this problem</a> on slow networks630      * using {@link com.nostra13.universalimageloader.core.assist.FlushedInputStream}.631      *632      * @author Sergey Tarasevich (nostra13[at]gmail[dot]com)633      * @since 1.8.1634      */635     private static class SlowNetworkImageDownloader implements ImageDownloader {636 637         private final ImageDownloader wrappedDownloader;638 639         public SlowNetworkImageDownloader(ImageDownloader wrappedDownloader) {640             this.wrappedDownloader = wrappedDownloader;641         }642 643         @Override644         public InputStream getStream(String imageUri, Object extra) throws IOException {645             InputStream imageStream = wrappedDownloader.getStream(imageUri, extra);646             switch (Scheme.ofUri(imageUri)) {647                 case HTTP:648                 case HTTPS:649                     return new FlushedInputStream(imageStream);650                 default:651                     return imageStream;652             }653         }654     }655 }

 

 Display Options

每一个ImageLoader.displayImage(...)都可以使用Display Options。

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

 Display Options的主要职责就是记录相关的配置，它的内部其实就是一些字段的集合（如下面的源代码）。它有一个builder的内部类，这个类中的字段跟DisplayOption中的字段完全一致，它有一些默认值，通过修改builder可以配置DisplayOptions。

public final class DisplayImageOptions {  2   3     private final int imageResOnLoading;  4     private final int imageResForEmptyUri;  5     private final int imageResOnFail;  6     private final Drawable imageOnLoading;  7     private final Drawable imageForEmptyUri;  8     private final Drawable imageOnFail;  9     private final boolean resetViewBeforeLoading; 10     private final boolean cacheInMemory; 11     private final boolean cacheOnDisk; 12     private final ImageScaleType imageScaleType; 13     private final Options decodingOptions; 14     private final int delayBeforeLoading; 15     private final boolean considerExifParams; 16     private final Object extraForDownloader; 17     private final BitmapProcessor preProcessor; 18     private final BitmapProcessor postProcessor; 19     private final BitmapDisplayer displayer; 20     private final Handler handler; 21     private final boolean isSyncLoading; 22  23     private DisplayImageOptions(Builder builder) { 24         imageResOnLoading = builder.imageResOnLoading; 25         imageResForEmptyUri = builder.imageResForEmptyUri; 26         imageResOnFail = builder.imageResOnFail; 27         imageOnLoading = builder.imageOnLoading; 28         imageForEmptyUri = builder.imageForEmptyUri; 29         imageOnFail = builder.imageOnFail; 30         resetViewBeforeLoading = builder.resetViewBeforeLoading; 31         cacheInMemory = builder.cacheInMemory; 32         cacheOnDisk = builder.cacheOnDisk; 33         imageScaleType = builder.imageScaleType; 34         decodingOptions = builder.decodingOptions; 35         delayBeforeLoading = builder.delayBeforeLoading; 36         considerExifParams = builder.considerExifParams; 37         extraForDownloader = builder.extraForDownloader; 38         preProcessor = builder.preProcessor; 39         postProcessor = builder.postProcessor; 40         displayer = builder.displayer; 41         handler = builder.handler; 42         isSyncLoading = builder.isSyncLoading; 43     } 44  45     public boolean shouldShowImageOnLoading() { 46         return imageOnLoading != null || imageResOnLoading != 0; 47     } 48  49     public boolean shouldShowImageForEmptyUri() { 50         return imageForEmptyUri != null || imageResForEmptyUri != 0; 51     } 52  53     public boolean shouldShowImageOnFail() { 54         return imageOnFail != null || imageResOnFail != 0; 55     } 56  57     public boolean shouldPreProcess() { 58         return preProcessor != null; 59     } 60  61     public boolean shouldPostProcess() { 62         return postProcessor != null; 63     } 64  65     public boolean shouldDelayBeforeLoading() { 66         return delayBeforeLoading > 0; 67     } 68  69     public Drawable getImageOnLoading(Resources res) { 70         return imageResOnLoading != 0 ? res.getDrawable(imageResOnLoading) : imageOnLoading; 71     } 72  73     public Drawable getImageForEmptyUri(Resources res) { 74         return imageResForEmptyUri != 0 ? res.getDrawable(imageResForEmptyUri) : imageForEmptyUri; 75     } 76  77     public Drawable getImageOnFail(Resources res) { 78         return imageResOnFail != 0 ? res.getDrawable(imageResOnFail) : imageOnFail; 79     } 80  81     public boolean isResetViewBeforeLoading() { 82         return resetViewBeforeLoading; 83     } 84  85     public boolean isCacheInMemory() { 86         return cacheInMemory; 87     } 88  89     public boolean isCacheOnDisk() { 90         return cacheOnDisk; 91     } 92  93     public ImageScaleType getImageScaleType() { 94         return imageScaleType; 95     } 96  97     public Options getDecodingOptions() { 98         return decodingOptions; 99     }100 101     public int getDelayBeforeLoading() {102         return delayBeforeLoading;103     }104 105     public boolean isConsiderExifParams() {106         return considerExifParams;107     }108 109     public Object getExtraForDownloader() {110         return extraForDownloader;111     }112 113     public BitmapProcessor getPreProcessor() {114         return preProcessor;115     }116 117     public BitmapProcessor getPostProcessor() {118         return postProcessor;119     }120 121     public BitmapDisplayer getDisplayer() {122         return displayer;123     }124 125     public Handler getHandler() {126         return handler;127     }128 129     boolean isSyncLoading() {130         return isSyncLoading;131     }132 133     /**134      * Builder for {@link DisplayImageOptions}135      *136      * @author Sergey Tarasevich (nostra13[at]gmail[dot]com)137      */138     public static class Builder {139         private int imageResOnLoading = 0;140         private int imageResForEmptyUri = 0;141         private int imageResOnFail = 0;142         private Drawable imageOnLoading = null;143         private Drawable imageForEmptyUri = null;144         private Drawable imageOnFail = null;145         private boolean resetViewBeforeLoading = false;146         private boolean cacheInMemory = false;147         private boolean cacheOnDisk = false;148         private ImageScaleType imageScaleType = ImageScaleType.IN_SAMPLE_POWER_OF_2;149         private Options decodingOptions = new Options();150         private int delayBeforeLoading = 0;151         private boolean considerExifParams = false;152         private Object extraForDownloader = null;153         private BitmapProcessor preProcessor = null;154         private BitmapProcessor postProcessor = null;155         private BitmapDisplayer displayer = DefaultConfigurationFactory.createBitmapDisplayer();156         private Handler handler = null;157         private boolean isSyncLoading = false;158 159         public Builder() {160             decodingOptions.inPurgeable = true;161             decodingOptions.inInputShareable = true;162         }163 164         /**165          * Stub image will be displayed in {@link com.nostra13.universalimageloader.core.imageaware.ImageAware166          * image aware view} during image loading167          *168          * @param imageRes Stub image resource169          * @deprecated Use {@link #showImageOnLoading(int)} instead170          */171         @Deprecated172         public Builder showStubImage(int imageRes) {173             imageResOnLoading = imageRes;174             return this;175         }176 177         /**178          * Incoming image will be displayed in {@link com.nostra13.universalimageloader.core.imageaware.ImageAware179          * image aware view} during image loading180          *181          * @param imageRes Image resource182          */183         public Builder showImageOnLoading(int imageRes) {184             imageResOnLoading = imageRes;185             return this;186         }187 188         /**189          * Incoming drawable will be displayed in {@link com.nostra13.universalimageloader.core.imageaware.ImageAware190          * image aware view} during image loading.191          * This option will be ignored if {@link DisplayImageOptions.Builder#showImageOnLoading(int)} is set.192          */193         public Builder showImageOnLoading(Drawable drawable) {194             imageOnLoading = drawable;195             return this;196         }197 198         /**199          * Incoming image will be displayed in {@link com.nostra13.universalimageloader.core.imageaware.ImageAware200          * image aware view} if empty URI (null or empty201          * string) will be passed to <b>ImageLoader.displayImage(...)</b> method.202          *203          * @param imageRes Image resource204          */205         public Builder showImageForEmptyUri(int imageRes) {206             imageResForEmptyUri = imageRes;207             return this;208         }209 210         /**211          * Incoming drawable will be displayed in {@link com.nostra13.universalimageloader.core.imageaware.ImageAware212          * image aware view} if empty URI (null or empty213          * string) will be passed to <b>ImageLoader.displayImage(...)</b> method.214          * This option will be ignored if {@link DisplayImageOptions.Builder#showImageForEmptyUri(int)} is set.215          */216         public Builder showImageForEmptyUri(Drawable drawable) {217             imageForEmptyUri = drawable;218             return this;219         }220 221         /**222          * Incoming image will be displayed in {@link com.nostra13.universalimageloader.core.imageaware.ImageAware223          * image aware view} if some error occurs during224          * requested image loading/decoding.225          *226          * @param imageRes Image resource227          */228         public Builder showImageOnFail(int imageRes) {229             imageResOnFail = imageRes;230             return this;231         }232 233         /**234          * Incoming drawable will be displayed in {@link com.nostra13.universalimageloader.core.imageaware.ImageAware235          * image aware view} if some error occurs during236          * requested image loading/decoding.237          * This option will be ignored if {@link DisplayImageOptions.Builder#showImageOnFail(int)} is set.238          */239         public Builder showImageOnFail(Drawable drawable) {240             imageOnFail = drawable;241             return this;242         }243 244         /**245          * {@link com.nostra13.universalimageloader.core.imageaware.ImageAware246          * image aware view} will be reset (set <b>null</b>) before image loading start247          *248          * @deprecated Use {@link #resetViewBeforeLoading(boolean) resetViewBeforeLoading(true)} instead249          */250         public Builder resetViewBeforeLoading() {251             resetViewBeforeLoading = true;252             return this;253         }254 255         /**256          * Sets whether {@link com.nostra13.universalimageloader.core.imageaware.ImageAware257          * image aware view} will be reset (set <b>null</b>) before image loading start258          */259         public Builder resetViewBeforeLoading(boolean resetViewBeforeLoading) {260             this.resetViewBeforeLoading = resetViewBeforeLoading;261             return this;262         }263 264         /**265          * Loaded image will be cached in memory266          *267          * @deprecated Use {@link #cacheInMemory(boolean) cacheInMemory(true)} instead268          */269         @Deprecated270         public Builder cacheInMemory() {271             cacheInMemory = true;272             return this;273         }274 275         /** Sets whether loaded image will be cached in memory */276         public Builder cacheInMemory(boolean cacheInMemory) {277             this.cacheInMemory = cacheInMemory;278             return this;279         }280 281         /**282          * Loaded image will be cached on disk283          *284          * @deprecated Use {@link #cacheOnDisk(boolean) cacheOnDisk(true)} instead285          */286         @Deprecated287         public Builder cacheOnDisc() {288             return cacheOnDisk(true);289         }290 291         /**292          * Sets whether loaded image will be cached on disk293          *294          * @deprecated Use {@link #cacheOnDisk(boolean)} instead295          */296         @Deprecated297         public Builder cacheOnDisc(boolean cacheOnDisk) {298             return cacheOnDisk(cacheOnDisk);299         }300 301         /** Sets whether loaded image will be cached on disk */302         public Builder cacheOnDisk(boolean cacheOnDisk) {303             this.cacheOnDisk = cacheOnDisk;304             return this;305         }306 307         /**308          * Sets {@linkplain ImageScaleType scale type} for decoding image. This parameter is used while define scale309          * size for decoding image to Bitmap. Default value - {@link ImageScaleType#IN_SAMPLE_POWER_OF_2}310          */311         public Builder imageScaleType(ImageScaleType imageScaleType) {312             this.imageScaleType = imageScaleType;313             return this;314         }315 316         /** Sets {@link Bitmap.Config bitmap config} for image decoding. Default value - {@link Bitmap.Config#ARGB_8888} */317         public Builder bitmapConfig(Bitmap.Config bitmapConfig) {318             if (bitmapConfig == null) throw new IllegalArgumentException("bitmapConfig can't be null");319             decodingOptions.inPreferredConfig = bitmapConfig;320             return this;321         }322 323         /**324          * Sets options for image decoding.<br />325          * <b>NOTE:</b> {@link Options#inSampleSize} of incoming options will <b>NOT</b> be considered. Library326          * calculate the most appropriate sample size itself according yo {@link #imageScaleType(ImageScaleType)}327          * options.<br />328          * <b>NOTE:</b> This option overlaps {@link #bitmapConfig(android.graphics.Bitmap.Config) bitmapConfig()}329          * option.330          */331         public Builder decodingOptions(Options decodingOptions) {332             if (decodingOptions == null) throw new IllegalArgumentException("decodingOptions can't be null");333             this.decodingOptions = decodingOptions;334             return this;335         }336 337         /** Sets delay time before starting loading task. Default - no delay. */338         public Builder delayBeforeLoading(int delayInMillis) {339             this.delayBeforeLoading = delayInMillis;340             return this;341         }342 343         /** Sets auxiliary object which will be passed to {@link ImageDownloader#getStream(String, Object)} */344         public Builder extraForDownloader(Object extra) {345             this.extraForDownloader = extra;346             return this;347         }348 349         /** Sets whether ImageLoader will consider EXIF parameters of JPEG image (rotate, flip) */350         public Builder considerExifParams(boolean considerExifParams) {351             this.considerExifParams = considerExifParams;352             return this;353         }354 355         /**356          * Sets bitmap processor which will be process bitmaps before they will be cached in memory. So memory cache357          * will contain bitmap processed by incoming preProcessor.<br />358          * Image will be pre-processed even if caching in memory is disabled.359          */360         public Builder preProcessor(BitmapProcessor preProcessor) {361             this.preProcessor = preProcessor;362             return this;363         }364 365         /**366          * Sets bitmap processor which will be process bitmaps before they will be displayed in367          * {@link com.nostra13.universalimageloader.core.imageaware.ImageAware image aware view} but368          * after they'll have been saved in memory cache.369          */370         public Builder postProcessor(BitmapProcessor postProcessor) {371             this.postProcessor = postProcessor;372             return this;373         }374 375         /**376          * Sets custom {@link BitmapDisplayer displayer} for image loading task. Default value -377          * {@link DefaultConfigurationFactory#createBitmapDisplayer()}378          */379         public Builder displayer(BitmapDisplayer displayer) {380             if (displayer == null) throw new IllegalArgumentException("displayer can't be null");381             this.displayer = displayer;382             return this;383         }384 385         Builder syncLoading(boolean isSyncLoading) {386             this.isSyncLoading = isSyncLoading;387             return this;388         }389 390         /**391          * Sets custom {@linkplain Handler handler} for displaying images and firing {@linkplain ImageLoadingListener392          * listener} events.393          */394         public Builder handler(Handler handler) {395             this.handler = handler;396             return this;397         }398 399         /** Sets all options equal to incoming options */400         public Builder cloneFrom(DisplayImageOptions options) {401             imageResOnLoading = options.imageResOnLoading;402             imageResForEmptyUri = options.imageResForEmptyUri;403             imageResOnFail = options.imageResOnFail;404             imageOnLoading = options.imageOnLoading;405             imageForEmptyUri = options.imageForEmptyUri;406             imageOnFail = options.imageOnFail;407             resetViewBeforeLoading = options.resetViewBeforeLoading;408             cacheInMemory = options.cacheInMemory;409             cacheOnDisk = options.cacheOnDisk;410             imageScaleType = options.imageScaleType;411             decodingOptions = options.decodingOptions;412             delayBeforeLoading = options.delayBeforeLoading;413             considerExifParams = options.considerExifParams;414             extraForDownloader = options.extraForDownloader;415             preProcessor = options.preProcessor;416             postProcessor = options.postProcessor;417             displayer = options.displayer;418             handler = options.handler;419             isSyncLoading = options.isSyncLoading;420             return this;421         }422 423         /** Builds configured {@link DisplayImageOptions} object */424         public DisplayImageOptions build() {425             return new DisplayImageOptions(this);426         }427     }428 429     /**430      * Creates options appropriate for single displaying:431      * <ul>432      * <li>View will <b>not</b> be reset before loading</li>433      * <li>Loaded image will <b>not</b> be cached in memory</li>434      * <li>Loaded image will <b>not</b> be cached on disk</li>435      * <li>{@link ImageScaleType#IN_SAMPLE_POWER_OF_2} decoding type will be used</li>436      * <li>{@link Bitmap.Config#ARGB_8888} bitmap config will be used for image decoding</li>437      * <li>{@link SimpleBitmapDisplayer} will be used for image displaying</li>438      * </ul>439      * <p/>440      * These option are appropriate for simple single-use image (from drawables or from Internet) displaying.441      */442     public static DisplayImageOptions createSimple() {443         return new Builder().build();444     }445 }

 

 

参考链接

http://blog.csdn.net/wangjinyu501/article/details/8091623

https://github.com/nostra13/Android-Universal-Image-Loader

http://www.intexsoft.com/blog/item/74-universal-image-loader-part-3