成都制作网站,游戏开发网站建设,常用网站建设技术是什么意思,网站建设公司发展一、介绍 Android-Universal-Image-Loader是一个开源的UI组件程序#xff0c;该项目的目的是提供一个可重复使用的仪器为异步图像加载#xff0c;缓存和显示。所以#xff0c;如果你的程序里需要这个功能的话#xff0c;那么不妨试试它。因为已经封装好了一些类和方法。我们…一、介绍 Android-Universal-Image-Loader是一个开源的UI组件程序该项目的目的是提供一个可重复使用的仪器为异步图像加载缓存和显示。所以如果你的程序里需要这个功能的话那么不妨试试它。因为已经封装好了一些类和方法。我们 可以直接拿来用了。而不用重复去写了。其实写一个这方面的程序还是比较麻烦的要考虑多线程缓存内存溢出等很多方面。
二、具体使用 一个好的类库的重要特征就是可配置性强。我们先简单使用Android-Universal-Image-Loader一般情况下使用默认配置就可以了。 下面的实例利用Android-Universal-Image-Loader将网络图片加载到图片墙中。 public class BaseActivity extends Activity {ImageLoader imageLoader;Overrideprotected void onCreate(Bundle savedInstanceState) {// Create global configuration and initialize ImageLoader with this configurationImageLoaderConfiguration config new ImageLoaderConfiguration.Builder(getApplicationContext()).build();ImageLoader.getInstance().init(config);super.onCreate(savedInstanceState);}
}
public class MainActivity extends BaseActivity {Overrideprotected void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);setContentView(R.layout.activity_main);ImageLoader imageLoader ImageLoader.getInstance();GridView gridView (GridView) this.findViewById(R.id.grdvImageWall);gridView.setAdapter(new PhotoWallAdapter(Constants.IMAGES));}static class ViewHolder {ImageView imageView;ProgressBar progressBar;}public class PhotoWallAdapter extends BaseAdapter {String[] imageUrls;ImageLoader imageLoad;DisplayImageOptions options;LinearLayout gridViewItem;public PhotoWallAdapter(String[] imageUrls) {assert imageUrls ! null;this.imageUrls imageUrls;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.considerExifParams(false) // default.imageScaleType(ImageScaleType.IN_SAMPLE_POWER_OF_2) // default.bitmapConfig(Bitmap.Config.ARGB_8888) // default.displayer(new SimpleBitmapDisplayer()) // default.handler(new Handler()) // default.build();this.imageLoad ImageLoader.getInstance();}Overridepublic int getCount() {return this.imageUrls.length;}Overridepublic Object getItem(int position) {if (position 0 || position this.imageUrls.length) {throw new IllegalArgumentException(position0||positionthis.imageUrls.length);}return this.imageUrls[position];}Overridepublic long getItemId(int position) {return position;}Overridepublic View getView(int position, View convertView, ViewGroup parent) {// 判断这个image是否已经在缓存当中如果没有就下载final ViewHolder holder;if (convertView null) {holder new ViewHolder();gridViewItem (LinearLayout) getLayoutInflater().inflate(R.layout.image_wall_item, null);holder.imageView (ImageView) gridViewItem.findViewById(R.id.item_image);holder.progressBar (ProgressBar) gridViewItem.findViewById(R.id.item_process);gridViewItem.setTag(holder);convertView gridViewItem;} else {holder (ViewHolder) gridViewItem.getTag();}this.imageLoad.displayImage(this.imageUrls[position],holder.imageView, options,new SimpleImageLoadingListener() {Overridepublic void onLoadingStarted(String imageUri, View view) {holder.progressBar.setProgress(0);holder.progressBar.setVisibility(View.VISIBLE);}Overridepublic void onLoadingFailed(String imageUri, View view,FailReason failReason) {holder.progressBar.setVisibility(View.GONE);}Overridepublic void onLoadingComplete(String imageUri,View view, Bitmap loadedImage) {holder.progressBar.setVisibility(View.GONE);}}, new ImageLoadingProgressListener() {Overridepublic void onProgressUpdate(String imageUri,View view, int current, int total) {holder.progressBar.setProgress(Math.round(100.0f* current / total));}}); // 通过URL判断图片是否已经下载return convertView;}}
} 里面主要的对象都用 突出显示了。
三者的关系 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。 /******************************************************************************** Copyright 2011-2013 Sergey Tarasevich** Licensed under the Apache License, Version 2.0 (the License);* you may not use this file except in compliance with the License.* You may obtain a copy of the License at** http://www.apache.org/licenses/LICENSE-2.0** Unless required by applicable law or agreed to in writing, software* distributed under the License is distributed on an AS IS BASIS,* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.* See the License for the specific language governing permissions and* limitations under the License.*******************************************************************************/
package com.nostra13.universalimageloader.core;import android.content.Context;
import android.content.res.Resources;
import android.util.DisplayMetrics;
import com.nostra13.universalimageloader.cache.disc.DiskCache;
import com.nostra13.universalimageloader.cache.disc.naming.FileNameGenerator;
import com.nostra13.universalimageloader.cache.memory.MemoryCache;
import com.nostra13.universalimageloader.cache.memory.impl.FuzzyKeyMemoryCache;
import com.nostra13.universalimageloader.core.assist.FlushedInputStream;
import com.nostra13.universalimageloader.core.assist.ImageSize;
import com.nostra13.universalimageloader.core.assist.QueueProcessingType;
import com.nostra13.universalimageloader.core.decode.ImageDecoder;
import com.nostra13.universalimageloader.core.download.ImageDownloader;
import com.nostra13.universalimageloader.core.process.BitmapProcessor;
import com.nostra13.universalimageloader.utils.L;
import com.nostra13.universalimageloader.utils.MemoryCacheUtils;import java.io.IOException;
import java.io.InputStream;
import java.util.concurrent.Executor;/*** Presents configuration for {link ImageLoader}** author Sergey Tarasevich (nostra13[at]gmail[dot]com)* see ImageLoader* see MemoryCache* see DiskCache* see DisplayImageOptions* see ImageDownloader* see FileNameGenerator* since 1.0.0*/
public final class ImageLoaderConfiguration {final Resources resources;final int maxImageWidthForMemoryCache;final int maxImageHeightForMemoryCache;final int maxImageWidthForDiskCache;final int maxImageHeightForDiskCache;final BitmapProcessor processorForDiskCache;final Executor taskExecutor;final Executor taskExecutorForCachedImages;final boolean customExecutor;final boolean customExecutorForCachedImages;final int threadPoolSize;final int threadPriority;final QueueProcessingType tasksProcessingType;final MemoryCache memoryCache;final DiskCache diskCache;final ImageDownloader downloader;final ImageDecoder decoder;final DisplayImageOptions defaultDisplayImageOptions;final ImageDownloader networkDeniedDownloader;final ImageDownloader slowNetworkDownloader;private ImageLoaderConfiguration(final Builder builder) {resources builder.context.getResources();maxImageWidthForMemoryCache builder.maxImageWidthForMemoryCache;maxImageHeightForMemoryCache builder.maxImageHeightForMemoryCache;maxImageWidthForDiskCache builder.maxImageWidthForDiskCache;maxImageHeightForDiskCache builder.maxImageHeightForDiskCache;processorForDiskCache builder.processorForDiskCache;taskExecutor builder.taskExecutor;taskExecutorForCachedImages builder.taskExecutorForCachedImages;threadPoolSize builder.threadPoolSize;threadPriority builder.threadPriority;tasksProcessingType builder.tasksProcessingType;diskCache builder.diskCache;memoryCache builder.memoryCache;defaultDisplayImageOptions builder.defaultDisplayImageOptions;downloader builder.downloader;decoder builder.decoder;customExecutor builder.customExecutor;customExecutorForCachedImages builder.customExecutorForCachedImages;networkDeniedDownloader new NetworkDeniedImageDownloader(downloader);slowNetworkDownloader new SlowNetworkImageDownloader(downloader);L.writeDebugLogs(builder.writeLogs);}/*** Creates default configuration for {link ImageLoader} br /* bDefault values:/b* ul* limaxImageWidthForMemoryCache devices screen width/li* limaxImageHeightForMemoryCache devices screen height/li* limaxImageWidthForDikcCache unlimited/li* limaxImageHeightForDiskCache unlimited/li* lithreadPoolSize {link Builder#DEFAULT_THREAD_POOL_SIZE this}/li* lithreadPriority {link Builder#DEFAULT_THREAD_PRIORITY this}/li* liallow to cache different sizes of image in memory/li* limemoryCache {link DefaultConfigurationFactory#createMemoryCache(int)}/li* lidiskCache {link com.nostra13.universalimageloader.cache.disc.impl.UnlimitedDiscCache}/li* liimageDownloader {link DefaultConfigurationFactory#createImageDownloader(Context)}/li* liimageDecoder {link DefaultConfigurationFactory#createImageDecoder(boolean)}/li* lidiskCacheFileNameGenerator {link DefaultConfigurationFactory#createFileNameGenerator()}/li* lidefaultDisplayImageOptions {link DisplayImageOptions#createSimple() Simple options}/li* litasksProcessingOrder {link QueueProcessingType#FIFO}/li* lidetailed logging disabled/li* /ul*/public static ImageLoaderConfiguration createDefault(Context context) {return new Builder(context).build();}ImageSize getMaxImageSize() {DisplayMetrics displayMetrics resources.getDisplayMetrics();int width maxImageWidthForMemoryCache;if (width 0) {width displayMetrics.widthPixels;}int height maxImageHeightForMemoryCache;if (height 0) {height displayMetrics.heightPixels;}return new ImageSize(width, height);}/*** Builder for {link ImageLoaderConfiguration}** author Sergey Tarasevich (nostra13[at]gmail[dot]com)*/public static class Builder {private static final String WARNING_OVERLAP_DISK_CACHE_PARAMS diskCache(), diskCacheSize() and diskCacheFileCount calls overlap each other;private static final String WARNING_OVERLAP_DISK_CACHE_NAME_GENERATOR diskCache() and diskCacheFileNameGenerator() calls overlap each other;private static final String WARNING_OVERLAP_MEMORY_CACHE memoryCache() and memoryCacheSize() calls overlap each other;private static final String WARNING_OVERLAP_EXECUTOR threadPoolSize(), threadPriority() and tasksProcessingOrder() calls can overlap taskExecutor() and taskExecutorForCachedImages() calls.;/** {value} */public static final int DEFAULT_THREAD_POOL_SIZE 3;/** {value} */public static final int DEFAULT_THREAD_PRIORITY Thread.NORM_PRIORITY - 1;/** {value} */public static final QueueProcessingType DEFAULT_TASK_PROCESSING_TYPE QueueProcessingType.FIFO;private Context context;private int maxImageWidthForMemoryCache 0;private int maxImageHeightForMemoryCache 0;private int maxImageWidthForDiskCache 0;private int maxImageHeightForDiskCache 0;private BitmapProcessor processorForDiskCache null;private Executor taskExecutor null;private Executor taskExecutorForCachedImages null;private boolean customExecutor false;private boolean customExecutorForCachedImages false;private int threadPoolSize DEFAULT_THREAD_POOL_SIZE;private int threadPriority DEFAULT_THREAD_PRIORITY;private boolean denyCacheImageMultipleSizesInMemory false;private QueueProcessingType tasksProcessingType DEFAULT_TASK_PROCESSING_TYPE;private int memoryCacheSize 0;private long diskCacheSize 0;private int diskCacheFileCount 0;private MemoryCache memoryCache null;private DiskCache diskCache null;private FileNameGenerator diskCacheFileNameGenerator null;private ImageDownloader downloader null;private ImageDecoder decoder;private DisplayImageOptions defaultDisplayImageOptions null;private boolean writeLogs false;public Builder(Context context) {this.context context.getApplicationContext();}/*** Sets options for memory cache** param maxImageWidthForMemoryCache Maximum image width which will be used for memory saving during decoding* an image to {link android.graphics.Bitmap Bitmap}. bDefault value - devices screen width/b* param maxImageHeightForMemoryCache Maximum image height which will be used for memory saving during decoding* an image to {link android.graphics.Bitmap Bitmap}. bDefault value/b - devices screen height*/public Builder memoryCacheExtraOptions(int maxImageWidthForMemoryCache, int maxImageHeightForMemoryCache) {this.maxImageWidthForMemoryCache maxImageWidthForMemoryCache;this.maxImageHeightForMemoryCache maxImageHeightForMemoryCache;return this;}/*** deprecated Use* {link #diskCacheExtraOptions(int, int, com.nostra13.universalimageloader.core.process.BitmapProcessor)}* instead*/Deprecatedpublic Builder discCacheExtraOptions(int maxImageWidthForDiskCache, int maxImageHeightForDiskCache,BitmapProcessor processorForDiskCache) {return diskCacheExtraOptions(maxImageWidthForDiskCache, maxImageHeightForDiskCache, processorForDiskCache);}/*** Sets options for resizing/compressing of downloaded images before saving to disk cache.br /* bNOTE: Use this option only when you have appropriate needs. It can make ImageLoader slower./b** param maxImageWidthForDiskCache Maximum width of downloaded images for saving at disk cache* param maxImageHeightForDiskCache Maximum height of downloaded images for saving at disk cache* param processorForDiskCache null-ok; {linkplain BitmapProcessor Bitmap processor} which process images before saving them in disc cache*/public Builder diskCacheExtraOptions(int maxImageWidthForDiskCache, int maxImageHeightForDiskCache,BitmapProcessor processorForDiskCache) {this.maxImageWidthForDiskCache maxImageWidthForDiskCache;this.maxImageHeightForDiskCache maxImageHeightForDiskCache;this.processorForDiskCache processorForDiskCache;return this;}/*** Sets custom {linkplain Executor executor} for tasks of loading and displaying images.br /* br /* bNOTE:/b If you set custom executor then following configuration options will not be considered for this* executor:* ul* li{link #threadPoolSize(int)}/li* li{link #threadPriority(int)}/li* li{link #tasksProcessingOrder(QueueProcessingType)}/li* /ul** see #taskExecutorForCachedImages(Executor)*/public Builder taskExecutor(Executor executor) {if (threadPoolSize ! DEFAULT_THREAD_POOL_SIZE || threadPriority ! DEFAULT_THREAD_PRIORITY || tasksProcessingType ! DEFAULT_TASK_PROCESSING_TYPE) {L.w(WARNING_OVERLAP_EXECUTOR);}this.taskExecutor executor;return this;}/*** Sets custom {linkplain Executor executor} for tasks of displaying bcached on disk/b images (these tasks* are executed quickly so UIL prefer to use separate executor for them).br /* br /* If you set the same executor for {linkplain #taskExecutor(Executor) general tasks} and* tasks about cached images (this method) then these tasks will be in the* same thread pool. So short-lived tasks can wait a long time for their turn.br /* br /* bNOTE:/b If you set custom executor then following configuration options will not be considered for this* executor:* ul* li{link #threadPoolSize(int)}/li* li{link #threadPriority(int)}/li* li{link #tasksProcessingOrder(QueueProcessingType)}/li* /ul** see #taskExecutor(Executor)*/public Builder taskExecutorForCachedImages(Executor executorForCachedImages) {if (threadPoolSize ! DEFAULT_THREAD_POOL_SIZE || threadPriority ! DEFAULT_THREAD_PRIORITY || tasksProcessingType ! DEFAULT_TASK_PROCESSING_TYPE) {L.w(WARNING_OVERLAP_EXECUTOR);}this.taskExecutorForCachedImages executorForCachedImages;return this;}/*** Sets thread pool size for image display tasks.br /* Default value - {link #DEFAULT_THREAD_POOL_SIZE this}*/public Builder threadPoolSize(int threadPoolSize) {if (taskExecutor ! null || taskExecutorForCachedImages ! null) {L.w(WARNING_OVERLAP_EXECUTOR);}this.threadPoolSize threadPoolSize;return this;}/*** Sets the priority for image loading threads. Should be bNOT/b greater than {link Thread#MAX_PRIORITY} or* less than {link Thread#MIN_PRIORITY}br /* Default value - {link #DEFAULT_THREAD_PRIORITY this}*/public Builder threadPriority(int threadPriority) {if (taskExecutor ! null || taskExecutorForCachedImages ! null) {L.w(WARNING_OVERLAP_EXECUTOR);}if (threadPriority Thread.MIN_PRIORITY) {this.threadPriority Thread.MIN_PRIORITY;} else {if (threadPriority Thread.MAX_PRIORITY) {this.threadPriority Thread.MAX_PRIORITY;} else {this.threadPriority threadPriority;}}return this;}/*** When you display an image in a small {link android.widget.ImageView ImageView} and later you try to display* this image (from identical URI) in a larger {link android.widget.ImageView ImageView} so decoded image of* bigger size will be cached in memory as a previous decoded image of smaller size.br /* So bthe default behavior is to allow to cache multiple sizes of one image in memory/b. You can* bdeny/b it by calling bthis/b method: so when some image will be cached in memory then previous* cached size of this image (if it exists) will be removed from memory cache before.*/public Builder denyCacheImageMultipleSizesInMemory() {this.denyCacheImageMultipleSizesInMemory true;return this;}/*** Sets type of queue processing for tasks for loading and displaying images.br /* Default value - {link QueueProcessingType#FIFO}*/public Builder tasksProcessingOrder(QueueProcessingType tasksProcessingType) {if (taskExecutor ! null || taskExecutorForCachedImages ! null) {L.w(WARNING_OVERLAP_EXECUTOR);}this.tasksProcessingType tasksProcessingType;return this;}/*** Sets maximum memory cache size for {link android.graphics.Bitmap bitmaps} (in bytes).br /* Default value - 1/8 of available app memory.br /* bNOTE:/b If you use this method then* {link com.nostra13.universalimageloader.cache.memory.impl.LruMemoryCache LruMemoryCache} will be used as* memory cache. You can use {link #memoryCache(MemoryCache)} method to set your own implementation of* {link MemoryCache}.*/public Builder memoryCacheSize(int memoryCacheSize) {if (memoryCacheSize 0) throw new IllegalArgumentException(memoryCacheSize must be a positive number);if (memoryCache ! null) {L.w(WARNING_OVERLAP_MEMORY_CACHE);}this.memoryCacheSize memoryCacheSize;return this;}/*** Sets maximum memory cache size (in percent of available app memory) for {link android.graphics.Bitmap* bitmaps}.br /* Default value - 1/8 of available app memory.br /* bNOTE:/b If you use this method then* {link com.nostra13.universalimageloader.cache.memory.impl.LruMemoryCache LruMemoryCache} will be used as* memory cache. You can use {link #memoryCache(MemoryCache)} method to set your own implementation of* {link MemoryCache}.*/public Builder memoryCacheSizePercentage(int availableMemoryPercent) {if (availableMemoryPercent 0 || availableMemoryPercent 100) {throw new IllegalArgumentException(availableMemoryPercent must be in range (0 % 100));}if (memoryCache ! null) {L.w(WARNING_OVERLAP_MEMORY_CACHE);}long availableMemory Runtime.getRuntime().maxMemory();memoryCacheSize (int) (availableMemory * (availableMemoryPercent / 100f));return this;}/*** Sets memory cache for {link android.graphics.Bitmap bitmaps}.br /* Default value - {link com.nostra13.universalimageloader.cache.memory.impl.LruMemoryCache LruMemoryCache}* with limited memory cache size (size 1/8 of available app memory)br /* br /* bNOTE:/b If you set custom memory cache then following configuration option will not be considered:* ul* li{link #memoryCacheSize(int)}/li* /ul*/public Builder memoryCache(MemoryCache memoryCache) {if (memoryCacheSize ! 0) {L.w(WARNING_OVERLAP_MEMORY_CACHE);}this.memoryCache memoryCache;return this;}/** deprecated Use {link #diskCacheSize(int)} instead */Deprecatedpublic Builder discCacheSize(int maxCacheSize) {return diskCacheSize(maxCacheSize);}/*** Sets maximum disk cache size for images (in bytes).br /* By default: disk cache is unlimited.br /* bNOTE:/b If you use this method then* {link com.nostra13.universalimageloader.cache.disc.impl.ext.LruDiscCache LruDiscCache}* will be used as disk cache. You can use {link #diskCache(DiskCache)} method for introduction your own* implementation of {link DiskCache}*/public Builder diskCacheSize(int maxCacheSize) {if (maxCacheSize 0) throw new IllegalArgumentException(maxCacheSize must be a positive number);if (diskCache ! null) {L.w(WARNING_OVERLAP_DISK_CACHE_PARAMS);}this.diskCacheSize maxCacheSize;return this;}/** deprecated Use {link #diskCacheFileCount(int)} instead */Deprecatedpublic Builder discCacheFileCount(int maxFileCount) {return diskCacheFileCount(maxFileCount);}/*** Sets maximum file count in disk cache directory.br /* By default: disk cache is unlimited.br /* bNOTE:/b If you use this method then* {link com.nostra13.universalimageloader.cache.disc.impl.ext.LruDiscCache LruDiscCache}* will be used as disk cache. You can use {link #diskCache(DiskCache)} method for introduction your own* implementation of {link DiskCache}*/public Builder diskCacheFileCount(int maxFileCount) {if (maxFileCount 0) throw new IllegalArgumentException(maxFileCount must be a positive number);if (diskCache ! null) {L.w(WARNING_OVERLAP_DISK_CACHE_PARAMS);}this.diskCacheFileCount maxFileCount;return this;}/** deprecated Use {link #diskCacheFileNameGenerator(com.nostra13.universalimageloader.cache.disc.naming.FileNameGenerator)} */Deprecatedpublic Builder discCacheFileNameGenerator(FileNameGenerator fileNameGenerator) {return diskCacheFileNameGenerator(fileNameGenerator);}/*** Sets name generator for files cached in disk cache.br /* Default value -* {link com.nostra13.universalimageloader.core.DefaultConfigurationFactory#createFileNameGenerator()* DefaultConfigurationFactory.createFileNameGenerator()}*/public Builder diskCacheFileNameGenerator(FileNameGenerator fileNameGenerator) {if (diskCache ! null) {L.w(WARNING_OVERLAP_DISK_CACHE_NAME_GENERATOR);}this.diskCacheFileNameGenerator fileNameGenerator;return this;}/** deprecated Use {link #diskCache(com.nostra13.universalimageloader.cache.disc.DiskCache)} */Deprecatedpublic Builder discCache(DiskCache diskCache) {return diskCache(diskCache);}/*** Sets disk cache for images.br /* Default value - {link com.nostra13.universalimageloader.cache.disc.impl.UnlimitedDiscCache* BaseDiscCache}. Cache directory is defined by* {link com.nostra13.universalimageloader.utils.StorageUtils#getCacheDirectory(Context)* StorageUtils.getCacheDirectory(Context)}.br /* br /* bNOTE:/b If you set custom disk cache then following configuration option will not be considered:* ul* li{link #diskCacheSize(int)}/li* li{link #diskCacheFileCount(int)}/li* li{link #diskCacheFileNameGenerator(FileNameGenerator)}/li* /ul*/public Builder diskCache(DiskCache diskCache) {if (diskCacheSize 0 || diskCacheFileCount 0) {L.w(WARNING_OVERLAP_DISK_CACHE_PARAMS);}if (diskCacheFileNameGenerator ! null) {L.w(WARNING_OVERLAP_DISK_CACHE_NAME_GENERATOR);}this.diskCache diskCache;return this;}/*** Sets utility which will be responsible for downloading of image.br /* Default value -* {link com.nostra13.universalimageloader.core.DefaultConfigurationFactory#createImageDownloader(Context)* DefaultConfigurationFactory.createImageDownloader()}*/public Builder imageDownloader(ImageDownloader imageDownloader) {this.downloader imageDownloader;return this;}/*** Sets utility which will be responsible for decoding of image stream.br /* Default value -* {link com.nostra13.universalimageloader.core.DefaultConfigurationFactory#createImageDecoder(boolean)* DefaultConfigurationFactory.createImageDecoder()}*/public Builder imageDecoder(ImageDecoder imageDecoder) {this.decoder imageDecoder;return this;}/*** Sets default {linkplain DisplayImageOptions display image options} for image displaying. These options will* be used for every {linkplain ImageLoader#displayImage(String, android.widget.ImageView) image display call}* without passing custom {linkplain DisplayImageOptions options}br /* Default value - {link DisplayImageOptions#createSimple() Simple options}*/public Builder defaultDisplayImageOptions(DisplayImageOptions defaultDisplayImageOptions) {this.defaultDisplayImageOptions defaultDisplayImageOptions;return this;}/*** Enables detail logging of {link ImageLoader} work. To prevent detail logs dont call this method.* Consider {link com.nostra13.universalimageloader.utils.L#disableLogging()} to disable* ImageLoader logging completely (even error logs)*/public Builder writeDebugLogs() {this.writeLogs true;return this;}/** Builds configured {link ImageLoaderConfiguration} object */public ImageLoaderConfiguration build() {initEmptyFieldsWithDefaultValues();return new ImageLoaderConfiguration(this);}private void initEmptyFieldsWithDefaultValues() {if (taskExecutor null) {taskExecutor DefaultConfigurationFactory.createExecutor(threadPoolSize, threadPriority, tasksProcessingType);} else {customExecutor true;}if (taskExecutorForCachedImages null) {taskExecutorForCachedImages DefaultConfigurationFactory.createExecutor(threadPoolSize, threadPriority, tasksProcessingType);} else {customExecutorForCachedImages true;}if (diskCache null) {if (diskCacheFileNameGenerator null) {diskCacheFileNameGenerator DefaultConfigurationFactory.createFileNameGenerator();}diskCache DefaultConfigurationFactory.createDiskCache(context, diskCacheFileNameGenerator, diskCacheSize, diskCacheFileCount);}if (memoryCache null) {memoryCache DefaultConfigurationFactory.createMemoryCache(memoryCacheSize);}if (denyCacheImageMultipleSizesInMemory) {memoryCache new FuzzyKeyMemoryCache(memoryCache, MemoryCacheUtils.createFuzzyKeyComparator());}if (downloader null) {downloader DefaultConfigurationFactory.createImageDownloader(context);}if (decoder null) {decoder DefaultConfigurationFactory.createImageDecoder(writeLogs);}if (defaultDisplayImageOptions null) {defaultDisplayImageOptions DisplayImageOptions.createSimple();}}}/*** Decorator. Prevents downloads from network (throws {link IllegalStateException exception}).br /* In most cases this downloader shouldnt be used directly.** author Sergey Tarasevich (nostra13[at]gmail[dot]com)* since 1.8.0*/private static class NetworkDeniedImageDownloader implements ImageDownloader {private final ImageDownloader wrappedDownloader;public NetworkDeniedImageDownloader(ImageDownloader wrappedDownloader) {this.wrappedDownloader wrappedDownloader;}Overridepublic InputStream getStream(String imageUri, Object extra) throws IOException {switch (Scheme.ofUri(imageUri)) {case HTTP:case HTTPS:throw new IllegalStateException();default:return wrappedDownloader.getStream(imageUri, extra);}}}/*** Decorator. Handles a hrefhttp://code.google.com/p/android/issues/detail?id6066this problem/a on slow networks* using {link com.nostra13.universalimageloader.core.assist.FlushedInputStream}.** author Sergey Tarasevich (nostra13[at]gmail[dot]com)* since 1.8.1*/private static class SlowNetworkImageDownloader implements ImageDownloader {private final ImageDownloader wrappedDownloader;public SlowNetworkImageDownloader(ImageDownloader wrappedDownloader) {this.wrappedDownloader wrappedDownloader;}Overridepublic InputStream getStream(String imageUri, Object extra) throws IOException {InputStream imageStream wrappedDownloader.getStream(imageUri, extra);switch (Scheme.ofUri(imageUri)) {case HTTP:case HTTPS:return new FlushedInputStream(imageStream);default:return imageStream;}}}
} 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 {private final int imageResOnLoading;private final int imageResForEmptyUri;private final int imageResOnFail;private final Drawable imageOnLoading;private final Drawable imageForEmptyUri;private final Drawable imageOnFail;private final boolean resetViewBeforeLoading;private final boolean cacheInMemory;private final boolean cacheOnDisk;private final ImageScaleType imageScaleType;private final Options decodingOptions;private final int delayBeforeLoading;private final boolean considerExifParams;private final Object extraForDownloader;private final BitmapProcessor preProcessor;private final BitmapProcessor postProcessor;private final BitmapDisplayer displayer;private final Handler handler;private final boolean isSyncLoading;private DisplayImageOptions(Builder builder) {imageResOnLoading builder.imageResOnLoading;imageResForEmptyUri builder.imageResForEmptyUri;imageResOnFail builder.imageResOnFail;imageOnLoading builder.imageOnLoading;imageForEmptyUri builder.imageForEmptyUri;imageOnFail builder.imageOnFail;resetViewBeforeLoading builder.resetViewBeforeLoading;cacheInMemory builder.cacheInMemory;cacheOnDisk builder.cacheOnDisk;imageScaleType builder.imageScaleType;decodingOptions builder.decodingOptions;delayBeforeLoading builder.delayBeforeLoading;considerExifParams builder.considerExifParams;extraForDownloader builder.extraForDownloader;preProcessor builder.preProcessor;postProcessor builder.postProcessor;displayer builder.displayer;handler builder.handler;isSyncLoading builder.isSyncLoading;}public boolean shouldShowImageOnLoading() {return imageOnLoading ! null || imageResOnLoading ! 0;}public boolean shouldShowImageForEmptyUri() {return imageForEmptyUri ! null || imageResForEmptyUri ! 0;}public boolean shouldShowImageOnFail() {return imageOnFail ! null || imageResOnFail ! 0;}public boolean shouldPreProcess() {return preProcessor ! null;}public boolean shouldPostProcess() {return postProcessor ! null;}public boolean shouldDelayBeforeLoading() {return delayBeforeLoading 0;}public Drawable getImageOnLoading(Resources res) {return imageResOnLoading ! 0 ? res.getDrawable(imageResOnLoading) : imageOnLoading;}public Drawable getImageForEmptyUri(Resources res) {return imageResForEmptyUri ! 0 ? res.getDrawable(imageResForEmptyUri) : imageForEmptyUri;}public Drawable getImageOnFail(Resources res) {return imageResOnFail ! 0 ? res.getDrawable(imageResOnFail) : imageOnFail;}public boolean isResetViewBeforeLoading() {return resetViewBeforeLoading;}public boolean isCacheInMemory() {return cacheInMemory;}public boolean isCacheOnDisk() {return cacheOnDisk;}public ImageScaleType getImageScaleType() {return imageScaleType;}public Options getDecodingOptions() {return decodingOptions;}public int getDelayBeforeLoading() {return delayBeforeLoading;}public boolean isConsiderExifParams() {return considerExifParams;}public Object getExtraForDownloader() {return extraForDownloader;}public BitmapProcessor getPreProcessor() {return preProcessor;}public BitmapProcessor getPostProcessor() {return postProcessor;}public BitmapDisplayer getDisplayer() {return displayer;}public Handler getHandler() {return handler;}boolean isSyncLoading() {return isSyncLoading;}/*** Builder for {link DisplayImageOptions}** author Sergey Tarasevich (nostra13[at]gmail[dot]com)*/public static class Builder {private int imageResOnLoading 0;private int imageResForEmptyUri 0;private int imageResOnFail 0;private Drawable imageOnLoading null;private Drawable imageForEmptyUri null;private Drawable imageOnFail null;private boolean resetViewBeforeLoading false;private boolean cacheInMemory false;private boolean cacheOnDisk false;private ImageScaleType imageScaleType ImageScaleType.IN_SAMPLE_POWER_OF_2;private Options decodingOptions new Options();private int delayBeforeLoading 0;private boolean considerExifParams false;private Object extraForDownloader null;private BitmapProcessor preProcessor null;private BitmapProcessor postProcessor null;private BitmapDisplayer displayer DefaultConfigurationFactory.createBitmapDisplayer();private Handler handler null;private boolean isSyncLoading false;public Builder() {decodingOptions.inPurgeable true;decodingOptions.inInputShareable true;}/*** Stub image will be displayed in {link com.nostra13.universalimageloader.core.imageaware.ImageAware* image aware view} during image loading** param imageRes Stub image resource* deprecated Use {link #showImageOnLoading(int)} instead*/Deprecatedpublic Builder showStubImage(int imageRes) {imageResOnLoading imageRes;return this;}/*** Incoming image will be displayed in {link com.nostra13.universalimageloader.core.imageaware.ImageAware* image aware view} during image loading** param imageRes Image resource*/public Builder showImageOnLoading(int imageRes) {imageResOnLoading imageRes;return this;}/*** Incoming drawable will be displayed in {link com.nostra13.universalimageloader.core.imageaware.ImageAware* image aware view} during image loading.* This option will be ignored if {link DisplayImageOptions.Builder#showImageOnLoading(int)} is set.*/public Builder showImageOnLoading(Drawable drawable) {imageOnLoading drawable;return this;}/*** Incoming image will be displayed in {link com.nostra13.universalimageloader.core.imageaware.ImageAware* image aware view} if empty URI (null or empty* string) will be passed to bImageLoader.displayImage(...)/b method.** param imageRes Image resource*/public Builder showImageForEmptyUri(int imageRes) {imageResForEmptyUri imageRes;return this;}/*** Incoming drawable will be displayed in {link com.nostra13.universalimageloader.core.imageaware.ImageAware* image aware view} if empty URI (null or empty* string) will be passed to bImageLoader.displayImage(...)/b method.* This option will be ignored if {link DisplayImageOptions.Builder#showImageForEmptyUri(int)} is set.*/public Builder showImageForEmptyUri(Drawable drawable) {imageForEmptyUri drawable;return this;}/*** Incoming image will be displayed in {link com.nostra13.universalimageloader.core.imageaware.ImageAware* image aware view} if some error occurs during* requested image loading/decoding.** param imageRes Image resource*/public Builder showImageOnFail(int imageRes) {imageResOnFail imageRes;return this;}/*** Incoming drawable will be displayed in {link com.nostra13.universalimageloader.core.imageaware.ImageAware* image aware view} if some error occurs during* requested image loading/decoding.* This option will be ignored if {link DisplayImageOptions.Builder#showImageOnFail(int)} is set.*/public Builder showImageOnFail(Drawable drawable) {imageOnFail drawable;return this;}/*** {link com.nostra13.universalimageloader.core.imageaware.ImageAware* image aware view} will be reset (set bnull/b) before image loading start** deprecated Use {link #resetViewBeforeLoading(boolean) resetViewBeforeLoading(true)} instead*/public Builder resetViewBeforeLoading() {resetViewBeforeLoading true;return this;}/*** Sets whether {link com.nostra13.universalimageloader.core.imageaware.ImageAware* image aware view} will be reset (set bnull/b) before image loading start*/public Builder resetViewBeforeLoading(boolean resetViewBeforeLoading) {this.resetViewBeforeLoading resetViewBeforeLoading;return this;}/*** Loaded image will be cached in memory** deprecated Use {link #cacheInMemory(boolean) cacheInMemory(true)} instead*/Deprecatedpublic Builder cacheInMemory() {cacheInMemory true;return this;}/** Sets whether loaded image will be cached in memory */public Builder cacheInMemory(boolean cacheInMemory) {this.cacheInMemory cacheInMemory;return this;}/*** Loaded image will be cached on disk** deprecated Use {link #cacheOnDisk(boolean) cacheOnDisk(true)} instead*/Deprecatedpublic Builder cacheOnDisc() {return cacheOnDisk(true);}/*** Sets whether loaded image will be cached on disk** deprecated Use {link #cacheOnDisk(boolean)} instead*/Deprecatedpublic Builder cacheOnDisc(boolean cacheOnDisk) {return cacheOnDisk(cacheOnDisk);}/** Sets whether loaded image will be cached on disk */public Builder cacheOnDisk(boolean cacheOnDisk) {this.cacheOnDisk cacheOnDisk;return this;}/*** Sets {linkplain ImageScaleType scale type} for decoding image. This parameter is used while define scale* size for decoding image to Bitmap. Default value - {link ImageScaleType#IN_SAMPLE_POWER_OF_2}*/public Builder imageScaleType(ImageScaleType imageScaleType) {this.imageScaleType imageScaleType;return this;}/** Sets {link Bitmap.Config bitmap config} for image decoding. Default value - {link Bitmap.Config#ARGB_8888} */public Builder bitmapConfig(Bitmap.Config bitmapConfig) {if (bitmapConfig null) throw new IllegalArgumentException(bitmapConfig cant be null);decodingOptions.inPreferredConfig bitmapConfig;return this;}/*** Sets options for image decoding.br /* bNOTE:/b {link Options#inSampleSize} of incoming options will bNOT/b be considered. Library* calculate the most appropriate sample size itself according yo {link #imageScaleType(ImageScaleType)}* options.br /* bNOTE:/b This option overlaps {link #bitmapConfig(android.graphics.Bitmap.Config) bitmapConfig()}* option.*/public Builder decodingOptions(Options decodingOptions) {if (decodingOptions null) throw new IllegalArgumentException(decodingOptions cant be null);this.decodingOptions decodingOptions;return this;}/** Sets delay time before starting loading task. Default - no delay. */public Builder delayBeforeLoading(int delayInMillis) {this.delayBeforeLoading delayInMillis;return this;}/** Sets auxiliary object which will be passed to {link ImageDownloader#getStream(String, Object)} */public Builder extraForDownloader(Object extra) {this.extraForDownloader extra;return this;}/** Sets whether ImageLoader will consider EXIF parameters of JPEG image (rotate, flip) */public Builder considerExifParams(boolean considerExifParams) {this.considerExifParams considerExifParams;return this;}/*** Sets bitmap processor which will be process bitmaps before they will be cached in memory. So memory cache* will contain bitmap processed by incoming preProcessor.br /* Image will be pre-processed even if caching in memory is disabled.*/public Builder preProcessor(BitmapProcessor preProcessor) {this.preProcessor preProcessor;return this;}/*** Sets bitmap processor which will be process bitmaps before they will be displayed in* {link com.nostra13.universalimageloader.core.imageaware.ImageAware image aware view} but* after theyll have been saved in memory cache.*/public Builder postProcessor(BitmapProcessor postProcessor) {this.postProcessor postProcessor;return this;}/*** Sets custom {link BitmapDisplayer displayer} for image loading task. Default value -* {link DefaultConfigurationFactory#createBitmapDisplayer()}*/public Builder displayer(BitmapDisplayer displayer) {if (displayer null) throw new IllegalArgumentException(displayer cant be null);this.displayer displayer;return this;}Builder syncLoading(boolean isSyncLoading) {this.isSyncLoading isSyncLoading;return this;}/*** Sets custom {linkplain Handler handler} for displaying images and firing {linkplain ImageLoadingListener* listener} events.*/public Builder handler(Handler handler) {this.handler handler;return this;}/** Sets all options equal to incoming options */public Builder cloneFrom(DisplayImageOptions options) {imageResOnLoading options.imageResOnLoading;imageResForEmptyUri options.imageResForEmptyUri;imageResOnFail options.imageResOnFail;imageOnLoading options.imageOnLoading;imageForEmptyUri options.imageForEmptyUri;imageOnFail options.imageOnFail;resetViewBeforeLoading options.resetViewBeforeLoading;cacheInMemory options.cacheInMemory;cacheOnDisk options.cacheOnDisk;imageScaleType options.imageScaleType;decodingOptions options.decodingOptions;delayBeforeLoading options.delayBeforeLoading;considerExifParams options.considerExifParams;extraForDownloader options.extraForDownloader;preProcessor options.preProcessor;postProcessor options.postProcessor;displayer options.displayer;handler options.handler;isSyncLoading options.isSyncLoading;return this;}/** Builds configured {link DisplayImageOptions} object */public DisplayImageOptions build() {return new DisplayImageOptions(this);}}/*** Creates options appropriate for single displaying:* ul* liView will bnot/b be reset before loading/li* liLoaded image will bnot/b be cached in memory/li* liLoaded image will bnot/b be cached on disk/li* li{link ImageScaleType#IN_SAMPLE_POWER_OF_2} decoding type will be used/li* li{link Bitmap.Config#ARGB_8888} bitmap config will be used for image decoding/li* li{link SimpleBitmapDisplayer} will be used for image displaying/li* /ul* p/* These option are appropriate for simple single-use image (from drawables or from Internet) displaying.*/public static DisplayImageOptions createSimple() {return new Builder().build();}
}参考链接 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.html
