首页 > 代码库 > Android-Universal-Image-Loader三大组件DisplayImageOptions、ImageLoader、ImageLoaderConfiguration详解
Android-Universal-Image-Loader三大组件DisplayImageOptions、ImageLoader、ImageLoaderConfiguration详解
一、介绍
Android-Universal-Image-Loader是一个开源的UI组件程序，该项目的目的是提供一个可重复使用的仪器为异步图像加载，缓存和显示。所以，如果你的程序里需要这个功能的话，那么不妨试试它。因为已经封装好了一些类和方法。我们 可以直接拿来用了。而不用重复去写了。其实，写一个这方面的程序还是比较麻烦的，要考虑多线程缓存，内存溢出等很多方面。
二、具体使用
很早就听过Android-Universal-Image-Loader这一开源框架，之前也试用过，但是一直没有认真地研究。一个好的类库的重要特征就是可配置性强。我们先简单试用Android-Universal-Image-Loader，一般情况下使用默认配置就可以了。
下面的实例利用Android-Universal-Image-Loader将网络图片加载到图片墙中。
1 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 }
1 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 onl oadingStarted(String imageUri, View view) { 91 holder.progressBar.setProgress(0); 92 holder.progressBar.setVisibility(View.VISIBLE); 93 } 94 95 @Override 96 public void onl oadingFailed(String imageUri, View view, 97 FailReason failReason) { 98 holder.progressBar.setVisibility(View.GONE); 99 }100 101 @Override102 public void onl oadingComplete(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。
1 /******************************************************************************* 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://www.mamicode.com/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。
1 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
声明：以上内容来自用户投稿及互联网公开渠道收集整理发布，本网站不拥有所有权，未作人工编辑处理，也不承担相关法律责任，若内容有误或涉及侵权可进行投诉： 投诉/举报 工作人员会在5个工作日内联系你，一经查实，本站将立刻删除涉嫌侵权内容。