我们知道建造者模式一般由Product、Builder、Director三个模块组成。但是在一般的开发中,Director角色经常被忽略。而直接使用一个Builder来进行对象的组装,这个Builder通常是链式调用,它的关键点是每个setter方法都返回自身,也就是return this,这样就使得setter方法可以链式调用,代码大致如下:
new TestBuilder().setA("A").setB("B").create();
通过这种形式,不紧去除了Director角色,整个结构也更加简单,也能对Product对象的组装过程有更精细的控制。
例子:
/**
* Created by niehongtao on 16/7/4.
*/
public class Product {
public String partA;
public String partB;
// 设置成私有的,强制要求只能从通过Bulider来建造这个对象,不能new
private Product(Builder builder) {
this.partA = builder.partA;
this.partB = builder.partB;
}
public static class Builder {
public String partA;
public String partB;
public Product.Builder buildPartA(String partA) {
this.partA = partA;
return this;
}
public Product.Builder buildPartB(String partB) {
this.partB = partB;
return this;
}
public Product build() {
return new Product(this);
}
}
}
Client
/**
* Created by niehongtao on 16/7/4.
*/
public class Client {
public static void main(String[] args) {
Product product = new Product.Builder().buildPartA("aaaa")
.buildPartB("bbbb")
.build();
System.out.print(product.partA + "::" + product.partB);
}
}
输出结果:
aaaa::bbbb
应用场景:
AlertDialog
/**
* 展示一个对话框,带确定和取消2个按钮(确定 取消)
*
* @param context
* 上下文,用来初始化Builder
* @param message
* 要在对话框上展示的内容
*/
public static void showOkCancelAlertDialog(Context context, String message,String ok,String cancel) {
AlertDialog.Builder builder = new Builder(context);
builder.setTitle("提示:");
builder.setMessage("" + message);
builder.setPositiveButton(ok,
new DialogInterface.OnClickListener() {
public void onClick(DialogInterface dialog, int which) {
dialog.cancel();
}
});
builder.setNegativeButton(cancel,
new DialogInterface.OnClickListener() {
public void onClick(DialogInterface dialog, int which) {
dialog.cancel();
}
});
AlertDialog dialog = builder.create();
dialog.setCancelable(false);
dialog.show();
}
universal imageloader的ImageLoaderConfiguration
//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//
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.DefaultConfigurationFactory;
import com.nostra13.universalimageloader.core.DisplayImageOptions;
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.download.ImageDownloader.Scheme;
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;
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(ImageLoaderConfiguration.Builder builder) {
this.resources = builder.context.getResources();
this.maxImageWidthForMemoryCache = builder.maxImageWidthForMemoryCache;
this.maxImageHeightForMemoryCache = builder.maxImageHeightForMemoryCache;
this.maxImageWidthForDiskCache = builder.maxImageWidthForDiskCache;
this.maxImageHeightForDiskCache = builder.maxImageHeightForDiskCache;
this.processorForDiskCache = builder.processorForDiskCache;
this.taskExecutor = builder.taskExecutor;
this.taskExecutorForCachedImages = builder.taskExecutorForCachedImages;
this.threadPoolSize = builder.threadPoolSize;
this.threadPriority = builder.threadPriority;
this.tasksProcessingType = builder.tasksProcessingType;
this.diskCache = builder.diskCache;
this.memoryCache = builder.memoryCache;
this.defaultDisplayImageOptions = builder.defaultDisplayImageOptions;
this.downloader = builder.downloader;
this.decoder = builder.decoder;
this.customExecutor = builder.customExecutor;
this.customExecutorForCachedImages = builder.customExecutorForCachedImages;
this.networkDeniedDownloader = new ImageLoaderConfiguration.NetworkDeniedImageDownloader(this.downloader);
this.slowNetworkDownloader = new ImageLoaderConfiguration.SlowNetworkImageDownloader(this.downloader);
L.writeDebugLogs(builder.writeLogs);
}
public static ImageLoaderConfiguration createDefault(Context context) {
return (new ImageLoaderConfiguration.Builder(context)).build();
}
ImageSize getMaxImageSize() {
DisplayMetrics displayMetrics = this.resources.getDisplayMetrics();
int width = this.maxImageWidthForMemoryCache;
if(width <= 0) {
width = displayMetrics.widthPixels;
}
int height = this.maxImageHeightForMemoryCache;
if(height <= 0) {
height = displayMetrics.heightPixels;
}
return new ImageSize(width, height);
}
private static class SlowNetworkImageDownloader implements ImageDownloader {
private final ImageDownloader wrappedDownloader;
public SlowNetworkImageDownloader(ImageDownloader wrappedDownloader) {
this.wrappedDownloader = wrappedDownloader;
}
public InputStream getStream(String imageUri, Object extra) throws IOException {
InputStream imageStream = this.wrappedDownloader.getStream(imageUri, extra);
switch(ImageLoaderConfiguration.SyntheticClass_1.$SwitchMap$com$nostra13$universalimageloader$core$download$ImageDownloader$Scheme[Scheme.ofUri(imageUri).ordinal()]) {
case 1:
case 2:
return new FlushedInputStream(imageStream);
default:
return imageStream;
}
}
}
private static class NetworkDeniedImageDownloader implements ImageDownloader {
private final ImageDownloader wrappedDownloader;
public NetworkDeniedImageDownloader(ImageDownloader wrappedDownloader) {
this.wrappedDownloader = wrappedDownloader;
}
public InputStream getStream(String imageUri, Object extra) throws IOException {
switch(ImageLoaderConfiguration.SyntheticClass_1.$SwitchMap$com$nostra13$universalimageloader$core$download$ImageDownloader$Scheme[Scheme.ofUri(imageUri).ordinal()]) {
case 1:
case 2:
throw new IllegalStateException();
default:
return this.wrappedDownloader.getStream(imageUri, extra);
}
}
}
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.";
public static final int DEFAULT_THREAD_POOL_SIZE = 3;
public static final int DEFAULT_THREAD_PRIORITY = 3;
public static final QueueProcessingType DEFAULT_TASK_PROCESSING_TYPE;
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 = 3;
private int threadPriority = 3;
private boolean denyCacheImageMultipleSizesInMemory = false;
private QueueProcessingType tasksProcessingType;
private int memoryCacheSize;
private long diskCacheSize;
private int diskCacheFileCount;
private MemoryCache memoryCache;
private DiskCache diskCache;
private FileNameGenerator diskCacheFileNameGenerator;
private ImageDownloader downloader;
private ImageDecoder decoder;
private DisplayImageOptions defaultDisplayImageOptions;
private boolean writeLogs;
public Builder(Context context) {
this.tasksProcessingType = DEFAULT_TASK_PROCESSING_TYPE;
this.memoryCacheSize = 0;
this.diskCacheSize = 0L;
this.diskCacheFileCount = 0;
this.memoryCache = null;
this.diskCache = null;
this.diskCacheFileNameGenerator = null;
this.downloader = null;
this.defaultDisplayImageOptions = null;
this.writeLogs = false;
this.context = context.getApplicationContext();
}
public ImageLoaderConfiguration.Builder memoryCacheExtraOptions(int maxImageWidthForMemoryCache, int maxImageHeightForMemoryCache) {
this.maxImageWidthForMemoryCache = maxImageWidthForMemoryCache;
this.maxImageHeightForMemoryCache = maxImageHeightForMemoryCache;
return this;
}
/** @deprecated */
@Deprecated
public ImageLoaderConfiguration.Builder discCacheExtraOptions(int maxImageWidthForDiskCache, int maxImageHeightForDiskCache, BitmapProcessor processorForDiskCache) {
return this.diskCacheExtraOptions(maxImageWidthForDiskCache, maxImageHeightForDiskCache, processorForDiskCache);
}
public ImageLoaderConfiguration.Builder diskCacheExtraOptions(int maxImageWidthForDiskCache, int maxImageHeightForDiskCache, BitmapProcessor processorForDiskCache) {
this.maxImageWidthForDiskCache = maxImageWidthForDiskCache;
this.maxImageHeightForDiskCache = maxImageHeightForDiskCache;
this.processorForDiskCache = processorForDiskCache;
return this;
}
public ImageLoaderConfiguration.Builder taskExecutor(Executor executor) {
if(this.threadPoolSize != 3 || this.threadPriority != 3 || this.tasksProcessingType != DEFAULT_TASK_PROCESSING_TYPE) {
L.w("threadPoolSize(), threadPriority() and tasksProcessingOrder() calls can overlap taskExecutor() and taskExecutorForCachedImages() calls.", new Object[0]);
}
this.taskExecutor = executor;
return this;
}
public ImageLoaderConfiguration.Builder taskExecutorForCachedImages(Executor executorForCachedImages) {
if(this.threadPoolSize != 3 || this.threadPriority != 3 || this.tasksProcessingType != DEFAULT_TASK_PROCESSING_TYPE) {
L.w("threadPoolSize(), threadPriority() and tasksProcessingOrder() calls can overlap taskExecutor() and taskExecutorForCachedImages() calls.", new Object[0]);
}
this.taskExecutorForCachedImages = executorForCachedImages;
return this;
}
public ImageLoaderConfiguration.Builder threadPoolSize(int threadPoolSize) {
if(this.taskExecutor != null || this.taskExecutorForCachedImages != null) {
L.w("threadPoolSize(), threadPriority() and tasksProcessingOrder() calls can overlap taskExecutor() and taskExecutorForCachedImages() calls.", new Object[0]);
}
this.threadPoolSize = threadPoolSize;
return this;
}
public ImageLoaderConfiguration.Builder threadPriority(int threadPriority) {
if(this.taskExecutor != null || this.taskExecutorForCachedImages != null) {
L.w("threadPoolSize(), threadPriority() and tasksProcessingOrder() calls can overlap taskExecutor() and taskExecutorForCachedImages() calls.", new Object[0]);
}
if(threadPriority < 1) {
this.threadPriority = 1;
} else if(threadPriority > 10) {
this.threadPriority = 10;
} else {
this.threadPriority = threadPriority;
}
return this;
}
public ImageLoaderConfiguration.Builder denyCacheImageMultipleSizesInMemory() {
this.denyCacheImageMultipleSizesInMemory = true;
return this;
}
public ImageLoaderConfiguration.Builder tasksProcessingOrder(QueueProcessingType tasksProcessingType) {
if(this.taskExecutor != null || this.taskExecutorForCachedImages != null) {
L.w("threadPoolSize(), threadPriority() and tasksProcessingOrder() calls can overlap taskExecutor() and taskExecutorForCachedImages() calls.", new Object[0]);
}
this.tasksProcessingType = tasksProcessingType;
return this;
}
public ImageLoaderConfiguration.Builder memoryCacheSize(int memoryCacheSize) {
if(memoryCacheSize <= 0) {
throw new IllegalArgumentException("memoryCacheSize must be a positive number");
} else {
if(this.memoryCache != null) {
L.w("memoryCache() and memoryCacheSize() calls overlap each other", new Object[0]);
}
this.memoryCacheSize = memoryCacheSize;
return this;
}
}
public ImageLoaderConfiguration.Builder memoryCacheSizePercentage(int availableMemoryPercent) {
if(availableMemoryPercent > 0 && availableMemoryPercent < 100) {
if(this.memoryCache != null) {
L.w("memoryCache() and memoryCacheSize() calls overlap each other", new Object[0]);
}
long availableMemory = Runtime.getRuntime().maxMemory();
this.memoryCacheSize = (int)((float)availableMemory * ((float)availableMemoryPercent / 100.0F));
return this;
} else {
throw new IllegalArgumentException("availableMemoryPercent must be in range (0 < % < 100)");
}
}
public ImageLoaderConfiguration.Builder memoryCache(MemoryCache memoryCache) {
if(this.memoryCacheSize != 0) {
L.w("memoryCache() and memoryCacheSize() calls overlap each other", new Object[0]);
}
this.memoryCache = memoryCache;
return this;
}
/** @deprecated */
@Deprecated
public ImageLoaderConfiguration.Builder discCacheSize(int maxCacheSize) {
return this.diskCacheSize(maxCacheSize);
}
public ImageLoaderConfiguration.Builder diskCacheSize(int maxCacheSize) {
if(maxCacheSize <= 0) {
throw new IllegalArgumentException("maxCacheSize must be a positive number");
} else {
if(this.diskCache != null) {
L.w("diskCache(), diskCacheSize() and diskCacheFileCount calls overlap each other", new Object[0]);
}
this.diskCacheSize = (long)maxCacheSize;
return this;
}
}
/** @deprecated */
@Deprecated
public ImageLoaderConfiguration.Builder discCacheFileCount(int maxFileCount) {
return this.diskCacheFileCount(maxFileCount);
}
public ImageLoaderConfiguration.Builder diskCacheFileCount(int maxFileCount) {
if(maxFileCount <= 0) {
throw new IllegalArgumentException("maxFileCount must be a positive number");
} else {
if(this.diskCache != null) {
L.w("diskCache(), diskCacheSize() and diskCacheFileCount calls overlap each other", new Object[0]);
}
this.diskCacheFileCount = maxFileCount;
return this;
}
}
/** @deprecated */
@Deprecated
public ImageLoaderConfiguration.Builder discCacheFileNameGenerator(FileNameGenerator fileNameGenerator) {
return this.diskCacheFileNameGenerator(fileNameGenerator);
}
public ImageLoaderConfiguration.Builder diskCacheFileNameGenerator(FileNameGenerator fileNameGenerator) {
if(this.diskCache != null) {
L.w("diskCache() and diskCacheFileNameGenerator() calls overlap each other", new Object[0]);
}
this.diskCacheFileNameGenerator = fileNameGenerator;
return this;
}
/** @deprecated */
@Deprecated
public ImageLoaderConfiguration.Builder discCache(DiskCache diskCache) {
return this.diskCache(diskCache);
}
public ImageLoaderConfiguration.Builder diskCache(DiskCache diskCache) {
if(this.diskCacheSize > 0L || this.diskCacheFileCount > 0) {
L.w("diskCache(), diskCacheSize() and diskCacheFileCount calls overlap each other", new Object[0]);
}
if(this.diskCacheFileNameGenerator != null) {
L.w("diskCache() and diskCacheFileNameGenerator() calls overlap each other", new Object[0]);
}
this.diskCache = diskCache;
return this;
}
public ImageLoaderConfiguration.Builder imageDownloader(ImageDownloader imageDownloader) {
this.downloader = imageDownloader;
return this;
}
public ImageLoaderConfiguration.Builder imageDecoder(ImageDecoder imageDecoder) {
this.decoder = imageDecoder;
return this;
}
public ImageLoaderConfiguration.Builder defaultDisplayImageOptions(DisplayImageOptions defaultDisplayImageOptions) {
this.defaultDisplayImageOptions = defaultDisplayImageOptions;
return this;
}
public ImageLoaderConfiguration.Builder writeDebugLogs() {
this.writeLogs = true;
return this;
}
public ImageLoaderConfiguration build() {
this.initEmptyFieldsWithDefaultValues();
return new ImageLoaderConfiguration(this, (ImageLoaderConfiguration.SyntheticClass_1)null);
}
private void initEmptyFieldsWithDefaultValues() {
if(this.taskExecutor == null) {
this.taskExecutor = DefaultConfigurationFactory.createExecutor(this.threadPoolSize, this.threadPriority, this.tasksProcessingType);
} else {
this.customExecutor = true;
}
if(this.taskExecutorForCachedImages == null) {
this.taskExecutorForCachedImages = DefaultConfigurationFactory.createExecutor(this.threadPoolSize, this.threadPriority, this.tasksProcessingType);
} else {
this.customExecutorForCachedImages = true;
}
if(this.diskCache == null) {
if(this.diskCacheFileNameGenerator == null) {
this.diskCacheFileNameGenerator = DefaultConfigurationFactory.createFileNameGenerator();
}
this.diskCache = DefaultConfigurationFactory.createDiskCache(this.context, this.diskCacheFileNameGenerator, this.diskCacheSize, this.diskCacheFileCount);
}
if(this.memoryCache == null) {
this.memoryCache = DefaultConfigurationFactory.createMemoryCache(this.context, this.memoryCacheSize);
}
if(this.denyCacheImageMultipleSizesInMemory) {
this.memoryCache = new FuzzyKeyMemoryCache(this.memoryCache, MemoryCacheUtils.createFuzzyKeyComparator());
}
if(this.downloader == null) {
this.downloader = DefaultConfigurationFactory.createImageDownloader(this.context);
}
if(this.decoder == null) {
this.decoder = DefaultConfigurationFactory.createImageDecoder(this.writeLogs);
}
if(this.defaultDisplayImageOptions == null) {
this.defaultDisplayImageOptions = DisplayImageOptions.createSimple();
}
}
static {
DEFAULT_TASK_PROCESSING_TYPE = QueueProcessingType.FIFO;
}
}
}
private void initImageLoader() {
ImageLoaderConfiguration config = new ImageLoaderConfiguration.Builder(context)
.threadPriority(Thread.NORM_PRIORITY - 2)
.denyCacheImageMultipleSizesInMemory()
.diskCacheFileNameGenerator(new Md5FileNameGenerator())
.diskCacheSize(50 * 1024 * 1024) // 50 Mb
.diskCacheFileCount(300)
.imageDownloader(new BaseImageDownloader(context))
.tasksProcessingOrder(QueueProcessingType.LIFO)
.build();
ImageLoader.getInstance().init(config);
}
universal imageloader的DisplayImageOptions
//两像素圆角
private DisplayImageOptions optionsRounded = new DisplayImageOptions.Builder()
.showImageOnLoading(R.mipmap.ic_launcher)
.showImageForEmptyUri(R.mipmap.ic_launcher)
.showImageOnFail(R.mipmap.ic_launcher)
.cacheInMemory(true)
.cacheOnDisk(true)
.considerExifParams(true)
.displayer(new RoundedBitmapDisplayer(2))
.build();
//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//
package com.nostra13.universalimageloader.core;
import android.content.res.Resources;
import android.graphics.Bitmap.Config;
import android.graphics.BitmapFactory.Options;
import android.graphics.drawable.Drawable;
import android.os.Handler;
import com.nostra13.universalimageloader.core.DefaultConfigurationFactory;
import com.nostra13.universalimageloader.core.assist.ImageScaleType;
import com.nostra13.universalimageloader.core.display.BitmapDisplayer;
import com.nostra13.universalimageloader.core.process.BitmapProcessor;
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(DisplayImageOptions.Builder builder) {
this.imageResOnLoading = builder.imageResOnLoading;
this.imageResForEmptyUri = builder.imageResForEmptyUri;
this.imageResOnFail = builder.imageResOnFail;
this.imageOnLoading = builder.imageOnLoading;
this.imageForEmptyUri = builder.imageForEmptyUri;
this.imageOnFail = builder.imageOnFail;
this.resetViewBeforeLoading = builder.resetViewBeforeLoading;
this.cacheInMemory = builder.cacheInMemory;
this.cacheOnDisk = builder.cacheOnDisk;
this.imageScaleType = builder.imageScaleType;
this.decodingOptions = builder.decodingOptions;
this.delayBeforeLoading = builder.delayBeforeLoading;
this.considerExifParams = builder.considerExifParams;
this.extraForDownloader = builder.extraForDownloader;
this.preProcessor = builder.preProcessor;
this.postProcessor = builder.postProcessor;
this.displayer = builder.displayer;
this.handler = builder.handler;
this.isSyncLoading = builder.isSyncLoading;
}
public boolean shouldShowImageOnLoading() {
return this.imageOnLoading != null || this.imageResOnLoading != 0;
}
public boolean shouldShowImageForEmptyUri() {
return this.imageForEmptyUri != null || this.imageResForEmptyUri != 0;
}
public boolean shouldShowImageOnFail() {
return this.imageOnFail != null || this.imageResOnFail != 0;
}
public boolean shouldPreProcess() {
return this.preProcessor != null;
}
public boolean shouldPostProcess() {
return this.postProcessor != null;
}
public boolean shouldDelayBeforeLoading() {
return this.delayBeforeLoading > 0;
}
public Drawable getImageOnLoading(Resources res) {
return this.imageResOnLoading != 0?res.getDrawable(this.imageResOnLoading):this.imageOnLoading;
}
public Drawable getImageForEmptyUri(Resources res) {
return this.imageResForEmptyUri != 0?res.getDrawable(this.imageResForEmptyUri):this.imageForEmptyUri;
}
public Drawable getImageOnFail(Resources res) {
return this.imageResOnFail != 0?res.getDrawable(this.imageResOnFail):this.imageOnFail;
}
public boolean isResetViewBeforeLoading() {
return this.resetViewBeforeLoading;
}
public boolean isCacheInMemory() {
return this.cacheInMemory;
}
public boolean isCacheOnDisk() {
return this.cacheOnDisk;
}
public ImageScaleType getImageScaleType() {
return this.imageScaleType;
}
public Options getDecodingOptions() {
return this.decodingOptions;
}
public int getDelayBeforeLoading() {
return this.delayBeforeLoading;
}
public boolean isConsiderExifParams() {
return this.considerExifParams;
}
public Object getExtraForDownloader() {
return this.extraForDownloader;
}
public BitmapProcessor getPreProcessor() {
return this.preProcessor;
}
public BitmapProcessor getPostProcessor() {
return this.postProcessor;
}
public BitmapDisplayer getDisplayer() {
return this.displayer;
}
public Handler getHandler() {
return this.handler;
}
boolean isSyncLoading() {
return this.isSyncLoading;
}
public static DisplayImageOptions createSimple() {
return (new DisplayImageOptions.Builder()).build();
}
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;
private Options decodingOptions;
private int delayBeforeLoading;
private boolean considerExifParams;
private Object extraForDownloader;
private BitmapProcessor preProcessor;
private BitmapProcessor postProcessor;
private BitmapDisplayer displayer;
private Handler handler;
private boolean isSyncLoading;
public Builder() {
this.imageScaleType = ImageScaleType.IN_SAMPLE_POWER_OF_2;
this.decodingOptions = new Options();
this.delayBeforeLoading = 0;
this.considerExifParams = false;
this.extraForDownloader = null;
this.preProcessor = null;
this.postProcessor = null;
this.displayer = DefaultConfigurationFactory.createBitmapDisplayer();
this.handler = null;
this.isSyncLoading = false;
}
/** @deprecated */
@Deprecated
public DisplayImageOptions.Builder showStubImage(int imageRes) {
this.imageResOnLoading = imageRes;
return this;
}
public DisplayImageOptions.Builder showImageOnLoading(int imageRes) {
this.imageResOnLoading = imageRes;
return this;
}
public DisplayImageOptions.Builder showImageOnLoading(Drawable drawable) {
this.imageOnLoading = drawable;
return this;
}
public DisplayImageOptions.Builder showImageForEmptyUri(int imageRes) {
this.imageResForEmptyUri = imageRes;
return this;
}
public DisplayImageOptions.Builder showImageForEmptyUri(Drawable drawable) {
this.imageForEmptyUri = drawable;
return this;
}
public DisplayImageOptions.Builder showImageOnFail(int imageRes) {
this.imageResOnFail = imageRes;
return this;
}
public DisplayImageOptions.Builder showImageOnFail(Drawable drawable) {
this.imageOnFail = drawable;
return this;
}
/** @deprecated */
public DisplayImageOptions.Builder resetViewBeforeLoading() {
this.resetViewBeforeLoading = true;
return this;
}
public DisplayImageOptions.Builder resetViewBeforeLoading(boolean resetViewBeforeLoading) {
this.resetViewBeforeLoading = resetViewBeforeLoading;
return this;
}
/** @deprecated */
@Deprecated
public DisplayImageOptions.Builder cacheInMemory() {
this.cacheInMemory = true;
return this;
}
public DisplayImageOptions.Builder cacheInMemory(boolean cacheInMemory) {
this.cacheInMemory = cacheInMemory;
return this;
}
/** @deprecated */
@Deprecated
public DisplayImageOptions.Builder cacheOnDisc() {
return this.cacheOnDisk(true);
}
/** @deprecated */
@Deprecated
public DisplayImageOptions.Builder cacheOnDisc(boolean cacheOnDisk) {
return this.cacheOnDisk(cacheOnDisk);
}
public DisplayImageOptions.Builder cacheOnDisk(boolean cacheOnDisk) {
this.cacheOnDisk = cacheOnDisk;
return this;
}
public DisplayImageOptions.Builder imageScaleType(ImageScaleType imageScaleType) {
this.imageScaleType = imageScaleType;
return this;
}
public DisplayImageOptions.Builder bitmapConfig(Config bitmapConfig) {
if(bitmapConfig == null) {
throw new IllegalArgumentException("bitmapConfig can\'t be null");
} else {
this.decodingOptions.inPreferredConfig = bitmapConfig;
return this;
}
}
public DisplayImageOptions.Builder decodingOptions(Options decodingOptions) {
if(decodingOptions == null) {
throw new IllegalArgumentException("decodingOptions can\'t be null");
} else {
this.decodingOptions = decodingOptions;
return this;
}
}
public DisplayImageOptions.Builder delayBeforeLoading(int delayInMillis) {
this.delayBeforeLoading = delayInMillis;
return this;
}
public DisplayImageOptions.Builder extraForDownloader(Object extra) {
this.extraForDownloader = extra;
return this;
}
public DisplayImageOptions.Builder considerExifParams(boolean considerExifParams) {
this.considerExifParams = considerExifParams;
return this;
}
public DisplayImageOptions.Builder preProcessor(BitmapProcessor preProcessor) {
this.preProcessor = preProcessor;
return this;
}
public DisplayImageOptions.Builder postProcessor(BitmapProcessor postProcessor) {
this.postProcessor = postProcessor;
return this;
}
public DisplayImageOptions.Builder displayer(BitmapDisplayer displayer) {
if(displayer == null) {
throw new IllegalArgumentException("displayer can\'t be null");
} else {
this.displayer = displayer;
return this;
}
}
DisplayImageOptions.Builder syncLoading(boolean isSyncLoading) {
this.isSyncLoading = isSyncLoading;
return this;
}
public DisplayImageOptions.Builder handler(Handler handler) {
this.handler = handler;
return this;
}
public DisplayImageOptions.Builder cloneFrom(DisplayImageOptions options) {
this.imageResOnLoading = options.imageResOnLoading;
this.imageResForEmptyUri = options.imageResForEmptyUri;
this.imageResOnFail = options.imageResOnFail;
this.imageOnLoading = options.imageOnLoading;
this.imageForEmptyUri = options.imageForEmptyUri;
this.imageOnFail = options.imageOnFail;
this.resetViewBeforeLoading = options.resetViewBeforeLoading;
this.cacheInMemory = options.cacheInMemory;
this.cacheOnDisk = options.cacheOnDisk;
this.imageScaleType = options.imageScaleType;
this.decodingOptions = options.decodingOptions;
this.delayBeforeLoading = options.delayBeforeLoading;
this.considerExifParams = options.considerExifParams;
this.extraForDownloader = options.extraForDownloader;
this.preProcessor = options.preProcessor;
this.postProcessor = options.postProcessor;
this.displayer = options.displayer;
this.handler = options.handler;
this.isSyncLoading = options.isSyncLoading;
return this;
}
public DisplayImageOptions build() {
return new DisplayImageOptions(this);
}
}
}