/*******************************************************************************
|
* Copyright 2011-2014 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.res.Resources;
|
import android.graphics.Bitmap;
|
import android.graphics.BitmapFactory.Options;
|
import android.graphics.drawable.Drawable;
|
import android.os.Handler;
|
import com.nostra13.universalimageloader.core.listener.ImageLoadingListener;
|
import com.nostra13.universalimageloader.core.assist.ImageScaleType;
|
import com.nostra13.universalimageloader.core.display.BitmapDisplayer;
|
import com.nostra13.universalimageloader.core.display.SimpleBitmapDisplayer;
|
import com.nostra13.universalimageloader.core.download.ImageDownloader;
|
import com.nostra13.universalimageloader.core.process.BitmapProcessor;
|
|
/**
|
* Contains options for image display. Defines:
|
* <ul>
|
* <li>whether stub image will be displayed in {@link com.nostra13.universalimageloader.core.imageaware.ImageAware
|
* image aware view} during image loading</li>
|
* <li>whether stub image will be displayed in {@link com.nostra13.universalimageloader.core.imageaware.ImageAware
|
* image aware view} if empty URI is passed</li>
|
* <li>whether stub image will be displayed in {@link com.nostra13.universalimageloader.core.imageaware.ImageAware
|
* image aware view} if image loading fails</li>
|
* <li>whether {@link com.nostra13.universalimageloader.core.imageaware.ImageAware image aware view} should be reset
|
* before image loading start</li>
|
* <li>whether loaded image will be cached in memory</li>
|
* <li>whether loaded image will be cached on disk</li>
|
* <li>image scale type</li>
|
* <li>decoding options (including bitmap decoding configuration)</li>
|
* <li>delay before loading of image</li>
|
* <li>whether consider EXIF parameters of image</li>
|
* <li>auxiliary object which will be passed to {@link ImageDownloader#getStream(String, Object) ImageDownloader}</li>
|
* <li>pre-processor for image Bitmap (before caching in memory)</li>
|
* <li>post-processor for image Bitmap (after caching in memory, before displaying)</li>
|
* <li>how decoded {@link Bitmap} will be displayed</li>
|
* </ul>
|
* <p/>
|
* You can create instance:
|
* <ul>
|
* <li>with {@link Builder}:<br />
|
* <b>i.e.</b> :
|
* <code>new {@link DisplayImageOptions}.{@link Builder#Builder() Builder()}.{@link Builder#cacheInMemory() cacheInMemory()}.
|
* {@link Builder#showImageOnLoading(int) showImageOnLoading()}.{@link Builder#build() build()}</code><br />
|
* </li>
|
* <li>or by static method: {@link #createSimple()}</li> <br />
|
*
|
* @author Sergey Tarasevich (nostra13[at]gmail[dot]com)
|
* @since 1.0.0
|
*/
|
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
|
*/
|
@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 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 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 <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 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 can't be null");
|
decodingOptions.inPreferredConfig = bitmapConfig;
|
return this;
|
}
|
|
/**
|
* Sets options for image decoding.<br />
|
* <b>NOTE:</b> {@link Options#inSampleSize} of incoming options will <b>NOT</b> be considered. Library
|
* calculate the most appropriate sample size itself according yo {@link #imageScaleType(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 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 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 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>
|
* <li>View will <b>not</b> be reset before loading</li>
|
* <li>Loaded image will <b>not</b> be cached in memory</li>
|
* <li>Loaded image will <b>not</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();
|
}
|
}
|
