ImageLoaderEngine(ImageLoaderConfiguration configuration) {
this.configuration = configuration;
taskExecutor = configuration.taskExecutor;
taskExecutorForCachedImages = configuration.taskExecutorForCachedImages;
taskDistributor = DefaultConfigurationFactory.createTaskDistributor();
}
private void initEmptyFiledsWithDefaultValues() {
if (discCache == null) {
if (discCacheFileNameGenerator == null) {
discCacheFileNameGenerator = DefaultConfigurationFactory.createFileNameGenerator();
}
discCache =
DefaultConfigurationFactory.createDiscCache(
context, discCacheFileNameGenerator, discCacheSize, discCacheFileCount);
}
if (memoryCache == null) {
memoryCache =
DefaultConfigurationFactory.createMemoryCache(
memoryCacheSize, denyCacheImageMultipleSizesInMemory);
}
if (downloader == null) {
downloader = DefaultConfigurationFactory.createImageDownloader(context);
}
if (defaultDisplayImageOptions == null) {
defaultDisplayImageOptions = DisplayImageOptions.createSimple();
}
}
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();
}
}
@Override
public void onCreate() {
super.onCreate();
application = this;
WindowManager wm = (WindowManager) this.getSystemService(WINDOW_SERVICE);
screenHeight = wm.getDefaultDisplay().getHeight();
screenWidth = wm.getDefaultDisplay().getWidth();
ImageLoaderConfiguration configuration =
new ImageLoaderConfiguration.Builder(this)
.memoryCacheExtraOptions(screenWidth, screenHeight) // 设置解析图片的大小，一般以手机屏幕大小为准
.diskCacheExtraOptions(screenWidth, screenHeight, null) // 保存到磁盘使用的大小以及压缩方法，默认原图保存
.threadPoolSize(3) // 线程池大小，不能太大，会出现OOM
.threadPriority(Thread.NORM_PRIORITY - 1) // 设置线程的优先程度 5-1
.tasksProcessingOrder(
QueueProcessingType.FIFO) // 设置图片加载和显示队列处理的类型 默认为QueueProcessingType.
// FIFO注:如果设置了taskExecutor或者taskExecutorForCachedImages 此设置无效
.memoryCache(new LruMemoryCache(2 * 1024 * 1024)) // 设置内存缓存 默认为一个当前应用可用内存的1/8大小的
.memoryCacheSize(2 * 1024 * 1014) // 设置内存缓存的最大大小 默认为一个当前应用可用内存的1/8
.memoryCacheSizePercentage(13) // 设置内存缓存最大大小占当前应用可用内存的百分比 默认为一个当前应用可用内存的1/8
.diskCache(
new UnlimitedDiskCache(
StorageUtils.getCacheDirectory(
getApplicationContext()))) // 默认为StorageUtils.getCacheDirectory(getApplicationContext()),即/mnt/sdcard/android/data/包名/cache/
.diskCacheSize(50 * 1024 * 1024) // 设置硬盘缓存的最大大小
.diskCacheFileCount(100) // 设置硬盘缓存的文件的最多个数
.diskCacheFileNameGenerator(new HashCodeFileNameGenerator()) // 设置硬盘缓存文件名生成规范
.imageDownloader(new BaseImageDownloader(this)) // 设置图片下载器
.imageDecoder(DefaultConfigurationFactory.createImageDecoder(false)) // 设置图片的解析器
.defaultDisplayImageOptions(DisplayImageOptions.createSimple()) // 设置默认的图片显示选项
.denyCacheImageMultipleSizesInMemory() // 不缓存图片的多种尺寸在内存中
.writeDebugLogs() // 打印调试Log,注意上线之前要去掉这句话
.imageDownloader(
new BaseImageDownloader(this, 5 * 1000, 30 * 1000)) // 图片下载器的设置 超时时间 读取时间
.build();
ImageLoader.getInstance().init(configuration); // 使用基本配置信息初始化ImageLoader
}
/**
* Builder for {@link com.nostra13.universalimageloader.core.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
*/
@Deprecated
public 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
* com.nostra13.universalimageloader.core.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 <b>ImageLoader.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 <b>ImageLoader.displayImage(...)</b> method. This
* option will be ignored if {@link
* com.nostra13.universalimageloader.core.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
* com.nostra13.universalimageloader.core.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 <b>null</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 <b>null</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
*/
@Deprecated
public 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
*/
@Deprecated
public Builder cacheOnDisc() {
return cacheOnDisk(true);
}
/**
* Sets whether loaded image will be cached on disk
*
* @deprecated Use {@link #cacheOnDisk(boolean)} instead
*/
@Deprecated
public 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 com.nostra13.universalimageloader.core.assist.ImageScaleType scale type} for
* decoding image. This parameter is used while define scale size for decoding image to Bitmap.
* Default value - {@link
* com.nostra13.universalimageloader.core.assist.ImageScaleType#IN_SAMPLE_POWER_OF_2}
*/
public Builder imageScaleType(ImageScaleType imageScaleType) {
this.imageScaleType = imageScaleType;
return this;
}
/**
* Sets {@link android.graphics.Bitmap.Config bitmap config} for image decoding. Default value -
* {@link android.graphics.Bitmap.Config#ARGB_8888}
*/
public Builder bitmapConfig(Bitmap.Config bitmapConfig) {
if (bitmapConfig == null) throw new IllegalArgumentException("bitmapConfig can't be null");
decodingOptions.inPreferredConfig = bitmapConfig;
return this;
}
/**
* Sets options for image decoding.<br>
* <b>NOTE:</b> {@link android.graphics.BitmapFactory.Options#inSampleSize} of incoming options
* will <b>NOT</b> be considered. Library calculate the most appropriate sample size itself
* according yo {@link
* #imageScaleType(com.nostra13.universalimageloader.core.assist.ImageScaleType)} options.<br>
* <b>NOTE:</b> This option overlaps {@link #bitmapConfig(android.graphics.Bitmap.Config)
* bitmapConfig()} option.
*/
public Builder decodingOptions(Options decodingOptions) {
if (decodingOptions == null)
throw new IllegalArgumentException("decodingOptions can't 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
* com.nostra13.universalimageloader.core.download.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
* they'll have been saved in memory cache.
*/
public Builder postProcessor(BitmapProcessor postProcessor) {
this.postProcessor = postProcessor;
return this;
}
/**
* Sets custom {@link com.nostra13.universalimageloader.core.display.BitmapDisplayer displayer}
* for image loading task. Default value - {@link
* DefaultConfigurationFactory#createBitmapDisplayer()}
*/
public Builder displayer(BitmapDisplayer displayer) {
if (displayer == null) throw new IllegalArgumentException("displayer can't be null");
this.displayer = displayer;
return this;
}
Builder syncLoading(boolean isSyncLoading) {
this.isSyncLoading = isSyncLoading;
return this;
}
/**
* Sets custom {@linkplain android.os.Handler handler} for displaying images and firing
* {@linkplain com.nostra13.universalimageloader.core.listener.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 com.nostra13.universalimageloader.core.DisplayImageOptions} object
*/
public DisplayImageOptions build() {
return new DisplayImageOptions(this);
}
}
private Executor createTaskExecutor() {
return DefaultConfigurationFactory.createExecutor(
configuration.threadPoolSize,
configuration.threadPriority,
configuration.tasksProcessingType);
}
public class DisplayImageOptions$Builder {
private int a = 0;
private int b = 0;
private int c = 0;
private Drawable d = null;
private Drawable e = null;
private Drawable f = null;
private boolean g = false;
private boolean h = false;
private boolean i = false;
private ImageScaleType j = ImageScaleType.IN_SAMPLE_POWER_OF_2;
private BitmapFactory.Options k = new BitmapFactory.Options();
private int l = 0;
private boolean m = false;
private Object n = null;
private BitmapProcessor o = null;
private BitmapProcessor p = null;
private BitmapDisplayer q = DefaultConfigurationFactory.createBitmapDisplayer();
private Handler r = null;
private boolean s = false;
public DisplayImageOptions$Builder() {
this.k.inPurgeable = true;
this.k.inInputShareable = true;
}
final Builder a(boolean paramBoolean) {
this.s = true;
return this;
}
public Builder bitmapConfig(Bitmap.Config paramConfig) {
if (paramConfig == null) throw new IllegalArgumentException("bitmapConfig can't be null");
this.k.inPreferredConfig = paramConfig;
return this;
}
public DisplayImageOptions build() {
return new DisplayImageOptions(this, (byte) 0);
}
public Builder cacheInMemory() {
this.h = true;
return this;
}
public Builder cacheInMemory(boolean paramBoolean) {
this.h = paramBoolean;
return this;
}
public Builder cacheOnDisc() {
return cacheOnDisk(true);
}
public Builder cacheOnDisc(boolean paramBoolean) {
return cacheOnDisk(paramBoolean);
}
public Builder cacheOnDisk(boolean paramBoolean) {
this.i = paramBoolean;
return this;
}
public Builder cloneFrom(DisplayImageOptions paramDisplayImageOptions) {
this.a = DisplayImageOptions.a(paramDisplayImageOptions);
this.b = DisplayImageOptions.b(paramDisplayImageOptions);
this.c = DisplayImageOptions.c(paramDisplayImageOptions);
this.d = DisplayImageOptions.d(paramDisplayImageOptions);
this.e = DisplayImageOptions.e(paramDisplayImageOptions);
this.f = DisplayImageOptions.f(paramDisplayImageOptions);
this.g = DisplayImageOptions.g(paramDisplayImageOptions);
this.h = DisplayImageOptions.h(paramDisplayImageOptions);
this.i = DisplayImageOptions.i(paramDisplayImageOptions);
this.j = DisplayImageOptions.j(paramDisplayImageOptions);
this.k = DisplayImageOptions.k(paramDisplayImageOptions);
this.l = DisplayImageOptions.l(paramDisplayImageOptions);
this.m = DisplayImageOptions.m(paramDisplayImageOptions);
this.n = DisplayImageOptions.n(paramDisplayImageOptions);
this.o = DisplayImageOptions.o(paramDisplayImageOptions);
this.p = DisplayImageOptions.p(paramDisplayImageOptions);
this.q = DisplayImageOptions.q(paramDisplayImageOptions);
this.r = DisplayImageOptions.r(paramDisplayImageOptions);
this.s = DisplayImageOptions.s(paramDisplayImageOptions);
return this;
}
public Builder considerExifParams(boolean paramBoolean) {
this.m = paramBoolean;
return this;
}
public Builder decodingOptions(BitmapFactory.Options paramOptions) {
if (paramOptions == null) throw new IllegalArgumentException("decodingOptions can't be null");
this.k = paramOptions;
return this;
}
public Builder delayBeforeLoading(int paramInt) {
this.l = paramInt;
return this;
}
public Builder displayer(BitmapDisplayer paramBitmapDisplayer) {
if (paramBitmapDisplayer == null) throw new IllegalArgumentException("displayer can't be null");
this.q = paramBitmapDisplayer;
return this;
}
public Builder extraForDownloader(Object paramObject) {
this.n = paramObject;
return this;
}
public Builder handler(Handler paramHandler) {
this.r = paramHandler;
return this;
}
public Builder imageScaleType(ImageScaleType paramImageScaleType) {
this.j = paramImageScaleType;
return this;
}
public Builder postProcessor(BitmapProcessor paramBitmapProcessor) {
this.p = paramBitmapProcessor;
return this;
}
public Builder preProcessor(BitmapProcessor paramBitmapProcessor) {
this.o = paramBitmapProcessor;
return this;
}
public Builder resetViewBeforeLoading() {
this.g = true;
return this;
}
public Builder resetViewBeforeLoading(boolean paramBoolean) {
this.g = paramBoolean;
return this;
}
public Builder showImageForEmptyUri(int paramInt) {
this.b = paramInt;
return this;
}
public Builder showImageForEmptyUri(Drawable paramDrawable) {
this.e = paramDrawable;
return this;
}
public Builder showImageOnFail(int paramInt) {
this.c = paramInt;
return this;
}
public Builder showImageOnFail(Drawable paramDrawable) {
this.f = paramDrawable;
return this;
}
public Builder showImageOnLoading(int paramInt) {
this.a = paramInt;
return this;
}
public Builder showImageOnLoading(Drawable paramDrawable) {
this.d = paramDrawable;
return this;
}
public Builder showStubImage(int paramInt) {
this.a = paramInt;
return this;
}
}
/**
* @param cacheDir Directory for file caching. <b>Important:</b> Specify separate folder for
* cached files. It's needed for right cache limit work.
* @param sizeLimit Cache limit value. If cache exceeds this limit then file with the most oldest
* last usage date will be deleted.
*/
public LimitedDiscCache(File cacheDir, int sizeLimit) {
this(cacheDir, DefaultConfigurationFactory.createFileNameGenerator(), sizeLimit);
}
/**
* @param cacheDir Directory for file caching. <b>Important:</b> Specify separate folder for
* cached files. It's needed for right cache limit work.
* @param maxCacheSize Maximum cache directory size (in bytes). If cache size exceeds this limit
* then file with the most oldest last usage date will be deleted.
*/
public TotalSizeLimitedDiscCache(File cacheDir, int maxCacheSize) {
this(cacheDir, DefaultConfigurationFactory.createFileNameGenerator(), maxCacheSize);
}
