xUtils 中的BitmapUtils 一些注释

/**

* 加载图片工具类

* @author afu

*

*/

public class BitmapUtils implements TaskHandler {

/**

* 判断任务是否暂停

*/

private boolean pauseTask = false;

/**

* 是否取消所有任务

*/

private boolean cancelAllTask = false;

private final Object pauseTaskLock = new Object();

/**

* Android上下文

*/
private Context context;

private BitmapGlobalConfig globalConfig;

private BitmapDisplayConfig defaultDisplayConfig;

/////////////////////////////////////////////// create ///////////////////////////////////////////////////

/**

*

* @param context 上下文

*/

public BitmapUtils(Context context) {

this(context, null);

}

/**

*

* @param context 上下文

* @param diskCachePath 磁盘高速缓存路径

*/

public BitmapUtils(Context context, String diskCachePath) {

if (context == null) {

throw new IllegalArgumentException("context may not be null");

}

this.context = context.getApplicationContext();

globalConfig = BitmapGlobalConfig.getInstance(this.context, diskCachePath);

defaultDisplayConfig = new BitmapDisplayConfig();

}

/**

*

* @param context 上下文

* @param diskCachePath 磁盘高速缓存路径

* @param memoryCacheSize 内存缓存空间大小

*/

public BitmapUtils(Context context, String diskCachePath, int memoryCacheSize) {

this(context, diskCachePath);

globalConfig.setMemoryCacheSize(memoryCacheSize);

}

/**

*

* @param context 上下文

* @param diskCachePath 磁盘高速缓存路径

* @param memoryCacheSize 内存缓存空间大小

* @param diskCacheSize 磁盘高速缓存空间大小

*/

public BitmapUtils(Context context, String diskCachePath, int memoryCacheSize, int diskCacheSize) {

this(context, diskCachePath);

globalConfig.setMemoryCacheSize(memoryCacheSize);

globalConfig.setDiskCacheSize(diskCacheSize);

}

/**

*

* @param context 上下文

* @param diskCachePath 磁盘高速缓存路径

* @param memoryCachePercent 内存缓存百分比

*/

public BitmapUtils(Context context, String diskCachePath, float memoryCachePercent) {

this(context, diskCachePath);

globalConfig.setMemCacheSizePercent(memoryCachePercent);

}

/**

*

* @param context 上下文

* @param diskCachePath 磁盘高速缓存路径

* @param memoryCachePercent 内存缓存百分比

* @param diskCacheSize 磁盘缓存空间大小

*/

public BitmapUtils(Context context, String diskCachePath, float memoryCachePercent, int diskCacheSize) {

this(context, diskCachePath);

globalConfig.setMemCacheSizePercent(memoryCachePercent);

globalConfig.setDiskCacheSize(diskCacheSize);

}

//config 配置

/**

* 配置默认加载drawable类型资源图片

* @param drawable

* @return

*/

public BitmapUtils configDefaultLoadingImage(Drawable drawable) {

defaultDisplayConfig.setLoadingDrawable(drawable);

return this;

}

/**

* 配置默认加载资源id类型资源图片

* @param resId

* @return

*/

public BitmapUtils configDefaultLoadingImage(int resId) {

defaultDisplayConfig.setLoadingDrawable(context.getResources().getDrawable(resId));

return this;

}

/**

* 配置默认加载图片

* @param bitmap bitmap类中的资源图片

* @return

*/

public BitmapUtils configDefaultLoadingImage(Bitmap bitmap) {

defaultDisplayConfig.setLoadingDrawable(new BitmapDrawable(context.getResources(), bitmap));

return this;

}

/**

* 设置默认加载失败的图片

* @param drawable drawable类型的资源图片

* @return

*/

public BitmapUtils configDefaultLoadFailedImage(Drawable drawable) {

defaultDisplayConfig.setLoadFailedDrawable(drawable);

return this;

}

/**

* 配置默认加载失败图片，加载id类型资源图片

* @param resId

* @return

*/

public BitmapUtils configDefaultLoadFailedImage(int resId) {

defaultDisplayConfig.setLoadFailedDrawable(context.getResources().getDrawable(resId));

return this;

}

/**

* 配置默认加载失败图片，加载Bitmap类型资源图片

* @param bitmap

* @return

*/

public BitmapUtils configDefaultLoadFailedImage(Bitmap bitmap) {

defaultDisplayConfig.setLoadFailedDrawable(new BitmapDrawable(context.getResources(), bitmap));

return this;

}

/**

* 配置默认图片最大宽和高

* @param maxWidth 最大宽

* @param maxHeight 最大高

* @return

*/

public BitmapUtils configDefaultBitmapMaxSize(int maxWidth, int maxHeight) {

defaultDisplayConfig.setBitmapMaxSize(new BitmapSize(maxWidth, maxHeight));

return this;

}

/**

* 配置默认位图最大图片参数

* @param maxSize 最大图片参数类

* @return

*/

public BitmapUtils configDefaultBitmapMaxSize(BitmapSize maxSize) {

defaultDisplayConfig.setBitmapMaxSize(maxSize);

return this;

}

/**

* 配置默认图片加载动画

* @param animation 动画

* @return

*/

public BitmapUtils configDefaultImageLoadAnimation(Animation animation) {

defaultDisplayConfig.setAnimation(animation);

return this;

}

/**

* 配置默认自动旋转动画

* @param autoRotation

* @return

*/

public BitmapUtils configDefaultAutoRotation(boolean autoRotation) {

defaultDisplayConfig.setAutoRotation(autoRotation);

return this;

}

/**

* 配置默认是否显示原始图片

* @param showOriginal true:显示原始图片，false：将会对图片压缩处理

* @return

*/

public BitmapUtils configDefaultShowOriginal(boolean showOriginal) {

defaultDisplayConfig.setShowOriginal(showOriginal);

return this;

}

/**

* 配置默认图片配置，传入Bitmap.Config类型

* @param config

* @return

*/

public BitmapUtils configDefaultBitmapConfig(Bitmap.Config config) {

defaultDisplayConfig.setBitmapConfig(config);

return this;

}

/**

* 配置默认显示配置

* @param displayConfig

* @return

*/

public BitmapUtils configDefaultDisplayConfig(BitmapDisplayConfig displayConfig) {

defaultDisplayConfig = displayConfig;

return this;

}

/**

* 配置下载参数

* @param downloader

* @return

*/

public BitmapUtils configDownloader(Downloader downloader) {

globalConfig.setDownloader(downloader);

return this;

}

/**

* 配置默认缓存失效

* @param defaultExpiry

* @return

*/

public BitmapUtils configDefaultCacheExpiry(long defaultExpiry) {

globalConfig.setDefaultCacheExpiry(defaultExpiry);

return this;

}

/**

* 配置默认链接时间超时时间

* @param connectTimeout 毫秒单位

* @return

*/

public BitmapUtils configDefaultConnectTimeout(int connectTimeout) {

globalConfig.setDefaultConnectTimeout(connectTimeout);

return this;

}

/**

* 配置默认读取超时时间

* @param readTimeout 毫秒

* @return

*/

public BitmapUtils configDefaultReadTimeout(int readTimeout) {

globalConfig.setDefaultReadTimeout(readTimeout);

return this;

}

/**

* 配置线程池多少

* @param threadPoolSize 线程池数

* 此参数没有设置，默认是设置5个核心线程池

* @return

*/

public BitmapUtils configThreadPoolSize(int threadPoolSize) {

globalConfig.setThreadPoolSize(threadPoolSize);

return this;

}

/**

* 配置内存缓存是否启用，默认是启用的

* @param enabled

* @return

*/

public BitmapUtils configMemoryCacheEnabled(boolean enabled) {

globalConfig.setMemoryCacheEnabled(enabled);

return this;

}

/**

* 配置磁盘缓存功能，默认是启用的

* @param enabled

* @return

*/

public BitmapUtils configDiskCacheEnabled(boolean enabled) {

globalConfig.setDiskCacheEnabled(enabled);

return this;

}

/**

* 配置原始磁盘缓存文件名称

* @param fileNameGenerator

* @return

*/

public BitmapUtils configDiskCacheFileNameGenerator(FileNameGenerator fileNameGenerator) {

globalConfig.setFileNameGenerator(fileNameGenerator);

return this;

}

/**

* 配置位图缓存监听

* @param listener

* @return

*/

public BitmapUtils configBitmapCacheListener(BitmapCacheListener listener) {

globalConfig.setBitmapCacheListener(listener);

return this;

}

////////////////////////// display 显示////////////////////////////////////

/**

* 根据图片路径，显示到具体的View上

* @param container 要把图片显示到的View

* @param uri 图片路径

*/

public <T extends View> void display(T container, String uri) {

display(container, uri, null, null);

}

/**

* 根据图片路径，显示到具体的View上

* @param container 要把图片显示到的View

* @param uri 图片路径

* @param displayConfig

*/

public <T extends View> void display(T container, String uri, BitmapDisplayConfig displayConfig) {

display(container, uri, displayConfig, null);

}

/**

* 根据图片路径，显示到具体的View上

* @param container 要把图片显示到的View

* @param uri 图片路径

* @param callBack 加载过程回调各种状态

*/

public <T extends View> void display(T container, String uri, BitmapLoadCallBack<T> callBack) {

display(container, uri, null, callBack);

}

/**

* 根据图片路径，显示到具体的View上

* @param container 要把图片显示到的View

* @param uri 图片路径

* @param displayConfig 位图显示配置

* @param callBack

*/

public <T extends View> void display(T container, String uri, BitmapDisplayConfig displayConfig, BitmapLoadCallBack<T> callBack) {

if (container == null) {

return;

}

if (callBack == null) {

callBack = new DefaultBitmapLoadCallBack<T>();

}

if (displayConfig == null || displayConfig == defaultDisplayConfig) {

displayConfig = defaultDisplayConfig.cloneNew();

}

// Optimize Max Size

BitmapSize size = displayConfig.getBitmapMaxSize();

displayConfig.setBitmapMaxSize(BitmapCommonUtils.optimizeMaxSizeByView(container, size.getWidth(), size.getHeight()));

container.clearAnimation();

if (TextUtils.isEmpty(uri)) {

callBack.onLoadFailed(container, uri, displayConfig.getLoadFailedDrawable());

return;

}

// start loading

callBack.onPreLoad(container, uri, displayConfig);

// find bitmap from mem cache.

Bitmap bitmap = globalConfig.getBitmapCache().getBitmapFromMemCache(uri, displayConfig);

if (bitmap != null) {

callBack.onLoadStarted(container, uri, displayConfig);

callBack.onLoadCompleted(

container,

uri,

bitmap,

displayConfig,

BitmapLoadFrom.MEMORY_CACHE);

} else if (!bitmapLoadTaskExist(container, uri, callBack)) {

final BitmapLoadTask<T> loadTask = new BitmapLoadTask<T>(container, uri, displayConfig, callBack);

// get executor

PriorityExecutor executor = globalConfig.getBitmapLoadExecutor();

File diskCacheFile = this.getBitmapFileFromDiskCache(uri);

boolean diskCacheExist = diskCacheFile != null && diskCacheFile.exists();

if (diskCacheExist && executor.isBusy()) {

executor = globalConfig.getDiskCacheExecutor();

}

// set loading image

Drawable loadingDrawable = displayConfig.getLoadingDrawable();

callBack.setDrawable(container, new AsyncDrawable<T>(loadingDrawable, loadTask));

loadTask.setPriority(displayConfig.getPriority());

loadTask.executeOnExecutor(executor);

}

}

/////////////////////////////////////////////// cache 缓存相关/////////////////////////////////////////////////////////////////

/**

* 清除内存和磁盘缓存

*/

public void clearCache() {

globalConfig.clearCache();

}

/**

* 清除内存缓存

*/

public void clearMemoryCache() {

globalConfig.clearMemoryCache();

}

/**

* 清除磁盘缓存

*/

public void clearDiskCache() {

globalConfig.clearDiskCache();

}

/**

* 根据uri清除内存缓存和磁盘缓存

* @param uri

*/

public void clearCache(String uri) {

globalConfig.clearCache(uri);

}

/**

* 根据uri清除内存缓存

* @param uri

*/

public void clearMemoryCache(String uri) {

globalConfig.clearMemoryCache(uri);

}

/**

* 根据uri清除磁盘缓存

* @param uri

*/

public void clearDiskCache(String uri) {

globalConfig.clearDiskCache(uri);

}

/**

* 刷新缓存

*/

public void flushCache() {

globalConfig.flushCache();

}

/**

* 关闭缓存

*/

public void closeCache() {

globalConfig.closeCache();

}

/**

* 根据uri从磁盘缓存得到位图文件

* @param uri

* @return

*/

public File getBitmapFileFromDiskCache(String uri) {

return globalConfig.getBitmapCache().getBitmapFileFromDiskCache(uri);

}

/**

* 根据uri和位图显示配置从磁盘缓存得到位图文件

* @param uri

* @param config

* @return

*/

public Bitmap getBitmapFromMemCache(String uri, BitmapDisplayConfig config) {

if (config == null) {

config = defaultDisplayConfig;

}

return globalConfig.getBitmapCache().getBitmapFromMemCache(uri, config);

}

////////////////////////////////////////// tasks 任务//////////////////////////////////////////////////////////////////////

/**

* 支持暂停

*/

@Override

public boolean supportPause() {

return true;

}

/**

* 支持重新开始

*/

@Override

public boolean supportResume() {

return true;

}

/**

* 支持取消

*/

@Override

public boolean supportCancel() {

return true;

}

/**

* 暂停

*/

@Override

public void pause() {

pauseTask = true;

flushCache();

}

/**

* 刷新

*/

@Override

public void resume() {

pauseTask = false;

synchronized (pauseTaskLock) {

pauseTaskLock.notifyAll();

}

}

/**

* 取消

*/

@Override

public void cancel() {

pauseTask = true;

cancelAllTask = true;

synchronized (pauseTaskLock) {

pauseTaskLock.notifyAll();

}

}

/**

* 是否暂停

*/

@Override

public boolean isPaused() {

return pauseTask;

}

/**

* 是否是取消了

*/

@Override

public boolean isCancelled() {

return cancelAllTask;

}

////////////////////////////////////////////////下面这些方法是否没有提供给开发者使用的///////////////////////////////////////////////////////////////

@SuppressWarnings("unchecked")

private static <T extends View> BitmapLoadTask<T> getBitmapTaskFromContainer(T container, BitmapLoadCallBack<T> callBack) {

if (container != null) {

final Drawable drawable = callBack.getDrawable(container);

if (drawable instanceof AsyncDrawable) {

final AsyncDrawable<T> asyncDrawable = (AsyncDrawable<T>) drawable;

return asyncDrawable.getBitmapWorkerTask();

}

}

return null;

}

private static <T extends View> boolean bitmapLoadTaskExist(T container, String uri, BitmapLoadCallBack<T> callBack) {

final BitmapLoadTask<T> oldLoadTask = getBitmapTaskFromContainer(container, callBack);

if (oldLoadTask != null) {

final String oldUrl = oldLoadTask.uri;

if (TextUtils.isEmpty(oldUrl) || !oldUrl.equals(uri)) {

oldLoadTask.cancel(true);

} else {

return true;

}

}

return false;

}

public class BitmapLoadTask<T extends View> extends PriorityAsyncTask<Object, Object, Bitmap> {

private final String uri;

private final WeakReference<T> containerReference;

private final BitmapLoadCallBack<T> callBack;

private final BitmapDisplayConfig displayConfig;

private BitmapLoadFrom from = BitmapLoadFrom.DISK_CACHE;

public BitmapLoadTask(T container, String uri, BitmapDisplayConfig config, BitmapLoadCallBack<T> callBack) {

if (container == null || uri == null || config == null || callBack == null) {

throw new IllegalArgumentException("args may not be null");

}

this.containerReference = new WeakReference<T>(container);

this.callBack = callBack;

this.uri = uri;

this.displayConfig = config;

}

@Override

protected Bitmap doInBackground(Object... params) {

synchronized (pauseTaskLock) {

while (pauseTask && !this.isCancelled()) {

try {

pauseTaskLock.wait();

if (cancelAllTask) {

return null;

}

} catch (Throwable e) {

}

}

}

Bitmap bitmap = null;

// get cache from disk cache

if (!this.isCancelled() && this.getTargetContainer() != null) {

this.publishProgress(PROGRESS_LOAD_STARTED);

bitmap = globalConfig.getBitmapCache().getBitmapFromDiskCache(uri, displayConfig);

}

// download image

if (bitmap == null && !this.isCancelled() && this.getTargetContainer() != null) {

bitmap = globalConfig.getBitmapCache().downloadBitmap(uri, displayConfig, this);

from = BitmapLoadFrom.URI;

}

return bitmap;

}

public void updateProgress(long total, long current) {

this.publishProgress(PROGRESS_LOADING, total, current);

}

private static final int PROGRESS_LOAD_STARTED = 0;

private static final int PROGRESS_LOADING = 1;

@Override

protected void onProgressUpdate(Object... values) {

if (values == null || values.length == 0) return;

final T container = this.getTargetContainer();

if (container == null) return;

switch ((Integer) values[0]) {

case PROGRESS_LOAD_STARTED:

callBack.onLoadStarted(container, uri, displayConfig);

break;

case PROGRESS_LOADING:

if (values.length != 3) return;

callBack.onLoading(container, uri, displayConfig, (Long) values[1], (Long) values[2]);

break;

default:

break;

}

}

@Override

protected void onPostExecute(Bitmap bitmap) {

final T container = this.getTargetContainer();

if (container != null) {

if (bitmap != null) {

callBack.onLoadCompleted(

container,

this.uri,

bitmap,

displayConfig,

from);

} else {

callBack.onLoadFailed(

container,

this.uri,

displayConfig.getLoadFailedDrawable());

}

}

}

@Override

protected void onCancelled(Bitmap bitmap) {

synchronized (pauseTaskLock) {

pauseTaskLock.notifyAll();

}

}

public T getTargetContainer() {

final T container = containerReference.get();

final BitmapLoadTask<T> bitmapWorkerTask = getBitmapTaskFromContainer(container, callBack);

if (this == bitmapWorkerTask) {

return container;

}

return null;

}

}

}