方法 |
注释 |
init |
初始化 ImageLoader 加载配置 |
defaultOptions |
获取 DisplayImageOptions 图片加载配置 |
getDefaultImageOptions |
获取图片默认加载配置 |
getNoCacheImageOptions |
获取不使用缓存的图片加载配置 |
getCacheImageOptions |
获取 ImageLoader 图片缓存加载配置 |
cloneImageOptions |
克隆图片加载配置 |
getFadeInBitmapDisplayer |
获取图片渐变动画加载配置 |
getRoundedBitmapDisplayer |
获取圆角图片加载配置 |
getBitmapDisplayerOptions |
获取图片效果加载配置 |
displayImage |
图片显示 |
loadImage |
图片加载 |
loadImageSync |
图片同步加载 |
clearDiskCache |
清除磁盘缓存 |
clearMemoryCache |
清除内存缓存 |
getDiskCache |
获取 SDCard 缓存空间 |
getMemoryCache |
获取 Memory 缓存空间 |
handleSlowNetwork |
设置是否处理弱网情况 |
denyNetworkDownloads |
设置是否禁止网络下载 |
cancelDisplayTask |
取消图片显示任务 |
getLoadingUriForView |
通过 ImageView 获取图片加载地址 |
setDefaultLoadingListener |
设置全局加载监听事件 |
destroy |
销毁操作 |
pause |
暂停图片加载 |
resume |
恢复图片加载 |
stop |
停止图片加载 |
package dev.other;
import android.content.Context;
import android.graphics.Bitmap;
import android.support.annotation.DrawableRes;
import android.widget.ImageView;
import com.nostra13.universalimageloader.cache.disc.DiskCache;
import com.nostra13.universalimageloader.cache.memory.MemoryCache;
import com.nostra13.universalimageloader.core.DisplayImageOptions;
import com.nostra13.universalimageloader.core.ImageLoader;
import com.nostra13.universalimageloader.core.ImageLoaderConfiguration;
import com.nostra13.universalimageloader.core.assist.ImageScaleType;
import com.nostra13.universalimageloader.core.assist.ImageSize;
import com.nostra13.universalimageloader.core.assist.QueueProcessingType;
import com.nostra13.universalimageloader.core.display.BitmapDisplayer;
import com.nostra13.universalimageloader.core.display.FadeInBitmapDisplayer;
import com.nostra13.universalimageloader.core.display.RoundedBitmapDisplayer;
import com.nostra13.universalimageloader.core.download.BaseImageDownloader;
import com.nostra13.universalimageloader.core.imageaware.ImageAware;
import com.nostra13.universalimageloader.core.listener.ImageLoadingListener;
import com.nostra13.universalimageloader.core.listener.ImageLoadingProgressListener;
/**
* detail: ImageLoader 工具类
* @author Ttt
* <pre>
* init: ImageLoaderUtils.init(getApplicationContext());
* use modify: 修改 defaultOptions() 配置、以及加载默认图片资源
* </pre>
*/
public final class ImageLoaderUtils {
private ImageLoaderUtils() {
}
// 图片加载中
private static int sImageLoadingRes = 0;
// 图片地址异常
private static int sImageUriErrorRes = 0;
// 图片 ( 加载 / 解码 ) 失败
private static int sImageFailRes = 0;
// 图片默认加载配置
private static final DisplayImageOptions DF_OPTIONS = defaultOptions();
// ========
// = init =
// ========
/**
* 初始化 ImageLoader 加载配置
* @param context {@link Context}
*/
public static void init(final Context context) {
DisplayImageOptions options = DF_OPTIONS;
// 针对图片缓存的全局加载配置 ( 主要有线程类、缓存大小、磁盘大小、图片下载与解析、日志方面的配置 )
ImageLoaderConfiguration config = new ImageLoaderConfiguration.Builder(context)
.defaultDisplayImageOptions(options) // 加载 DisplayImageOptions 参数
.threadPriority(Thread.NORM_PRIORITY - 2) // 线程池内加载的数量
.denyCacheImageMultipleSizesInMemory() // 加载同一 URL 图片时 imageView 从小变大时从内存缓存中加载
//.memoryCache(new UsingFreqLimitedMemoryCache(1024 * 1024)) // 通过自己的内存缓存实现
.memoryCacheSize(2 * 1024 * 1024) // 内存缓存最大值
.memoryCacheSizePercentage(13)
//.diskCacheSize(50 * 1024 * 1024) // SDCard 缓存最大值 50mb
//.discCacheFileNameGenerator(new Md5FileNameGenerator()) // 将保存的时候的 URI 名称用 MD5 加密
//.diskCacheFileCount(100) // 缓存的文件数量
//.memoryCache(new WeakMemoryCache()).diskCacheFileNameGenerator(new HashCodeFileNameGenerator())
.imageDownloader(new BaseImageDownloader(context)) // default
.tasksProcessingOrder(QueueProcessingType.LIFO).build();
ImageLoader.getInstance().init(config);
}
// =======================
// = DisplayImageOptions =
// =======================
/**
* 获取 DisplayImageOptions 图片加载配置
* @return {@link DisplayImageOptions}
*/
public static DisplayImageOptions defaultOptions() {
DisplayImageOptions options = new DisplayImageOptions.Builder()
.showImageOnLoading(sImageLoadingRes) // 设置图片在下载期间显示的图片
.showImageForEmptyUri(sImageUriErrorRes) // 设置图片 Uri 为空或是错误的时候显示的图片
.showImageOnFail(sImageFailRes) // 设置图片 ( 加载 / 解码 ) 过程中错误时候显示的图片
.imageScaleType(ImageScaleType.EXACTLY) // 设置图片缩放
.bitmapConfig(Bitmap.Config.RGB_565) // 图片解码类型
.cacheInMemory(true) // 是否保存到内存
.considerExifParams(false) // 是否考虑 JPEG 图像 EXIF 参数 ( 旋转、翻转 )
.resetViewBeforeLoading(false) // default 设置图片在加载前是否重置、复位
//.displayer(new FadeInBitmapDisplayer(100)) // 图片加载好后渐入的动画时间
.cacheOnDisk(true).build(); // 是否保存到 SDCard 上
return options;
}
/**
* 获取图片默认加载配置
* @param loadingRes 设置加载中显示的图片
* @return {@link DisplayImageOptions}
*/
public static DisplayImageOptions getDefaultImageOptions(@DrawableRes final int loadingRes) {
DisplayImageOptions.Builder optionsBuilder = cloneImageOptions(DF_OPTIONS);
optionsBuilder.showImageOnLoading(loadingRes) // 设置图片在下载期间显示的图片
.showImageForEmptyUri(loadingRes) // 设置图片 Uri 为空或是错误的时候显示的图片
.showImageOnFail(loadingRes); // 设置图片 ( 加载 / 解码 ) 过程中错误时候显示的图片
return optionsBuilder.build();
}
/**
* 获取不使用缓存的图片加载配置
* @return {@link DisplayImageOptions}
*/
public static DisplayImageOptions getNoCacheImageOptions() {
return getCacheImageOptions(false, false, -1);
}
/**
* 获取不使用缓存的图片加载配置
* @param loadingRes 设置加载中显示的图片
* @return {@link DisplayImageOptions}
*/
public static DisplayImageOptions getNoCacheImageOptions(@DrawableRes final int loadingRes) {
return getCacheImageOptions(false, false, loadingRes);
}
/**
* 获取 ImageLoader 图片缓存加载配置
* @param isCache 是否缓存在内存中
* @param isCacheDisk 是否保存在 SDCard
* @return {@link DisplayImageOptions}
*/
public static DisplayImageOptions getCacheImageOptions(final boolean isCache, final boolean isCacheDisk) {
return getCacheImageOptions(isCache, isCacheDisk, -1);
}
/**
* 获取 ImageLoader 图片加载配置
* @param isCache 是否缓存在内存中
* @param isCacheDisk 是否保存在 SDCard
* @param loadingRes 设置加载中显示的图片
* @return {@link DisplayImageOptions}
*/
public static DisplayImageOptions getCacheImageOptions(final boolean isCache,
final boolean isCacheDisk,
@DrawableRes final int loadingRes) {
DisplayImageOptions.Builder builder = new DisplayImageOptions.Builder()
.imageScaleType(ImageScaleType.EXACTLY) // 设置图片缩放
.bitmapConfig(Bitmap.Config.RGB_565) // 图片解码类型
.cacheInMemory(isCache) // 是否保存到内存
.displayer(new RoundedBitmapDisplayer(20))
.cacheOnDisk(isCacheDisk); // 是否保存到 SDCard 上
// 判断是否使用加载图片
if (loadingRes != 0) {
builder.showImageOnLoading(loadingRes) // 设置图片在下载期间显示的图片
.showImageForEmptyUri(loadingRes) // 设置图片 Uri 为空或是错误的时候显示的图片
.showImageOnFail(loadingRes); // 设置图片 ( 加载 / 解码 ) 过程中错误时候显示的图片
}
return builder.build();
}
/**
* 克隆图片加载配置
* @param options 待克隆加载配置
* @return {@link DisplayImageOptions}
*/
public static DisplayImageOptions.Builder cloneImageOptions(final DisplayImageOptions options) {
return (options != null) ? new DisplayImageOptions.Builder().cloneFrom(options) : null;
}
// ============
// = 图片效果 =
// ============
/**
* 获取图片渐变动画加载配置
* @param durationMillis 动画持续时间
* @return {@link DisplayImageOptions}
*/
public static DisplayImageOptions getFadeInBitmapDisplayer(final int durationMillis) {
return getBitmapDisplayerOptions(cloneImageOptions(DF_OPTIONS).build(), new FadeInBitmapDisplayer(durationMillis));
}
/**
* 获取图片渐变动画加载配置
* @param options {@link DisplayImageOptions}
* @param durationMillis 动画持续时间
* @return {@link DisplayImageOptions}
*/
public static DisplayImageOptions getFadeInBitmapDisplayer(final DisplayImageOptions options, final int durationMillis) {
if (options != null) {
return getBitmapDisplayerOptions(options, new FadeInBitmapDisplayer(durationMillis));
}
return options;
}
// =
/**
* 获取圆角图片加载配置
* @param cornerRadiusPixels 圆角大小
* @return {@link DisplayImageOptions}
*/
public static DisplayImageOptions getRoundedBitmapDisplayer(final int cornerRadiusPixels) {
return getBitmapDisplayerOptions(cloneImageOptions(DF_OPTIONS).build(), new RoundedBitmapDisplayer(cornerRadiusPixels));
}
/**
* 获取圆角图片加载配置
* @param options {@link DisplayImageOptions}
* @param cornerRadiusPixels 圆角大小
* @return {@link DisplayImageOptions}
*/
public static DisplayImageOptions getRoundedBitmapDisplayer(final DisplayImageOptions options, final int cornerRadiusPixels) {
if (options != null) {
return getBitmapDisplayerOptions(options, new RoundedBitmapDisplayer(cornerRadiusPixels));
}
return options;
}
/**
* 获取图片效果加载配置
* @param options {@link DisplayImageOptions}
* @param displayer {@link BitmapDisplayer}
* @return {@link DisplayImageOptions}
*/
public static DisplayImageOptions getBitmapDisplayerOptions(final DisplayImageOptions options, final BitmapDisplayer displayer) {
if (options != null && displayer != null) {
return cloneImageOptions(options).displayer(displayer).build();
}
return null;
}
// ============
// = 图片显示 =
// ============
/**
* 图片显示
* @param uri Image Uri
* @param imageView ImageView
*/
public static void displayImage(final String uri, final ImageView imageView) {
if (imageView != null) ImageLoader.getInstance().displayImage(uri, imageView);
}
/**
* 图片显示
* @param uri Image Uri
* @param imageView ImageView
* @param options {@link DisplayImageOptions}
*/
public static void displayImage(final String uri, final ImageView imageView, final DisplayImageOptions options) {
if (imageView != null) {
// 判断是否使用自定义图片加载配置
if (options != null) {
ImageLoader.getInstance().displayImage(uri, imageView, options);
} else {
ImageLoader.getInstance().displayImage(uri, imageView);
}
}
}
/**
* 图片显示
* @param uri Image Uri
* @param imageView ImageView
* @param imageSize {@link ImageSize}
*/
public static void displayImage(final String uri, final ImageView imageView, final ImageSize imageSize) {
if (imageView != null && imageSize != null) {
ImageLoader.getInstance().displayImage(uri, imageView, imageSize);
}
}
/**
* 图片显示
* @param uri Image Uri
* @param imageAware new ImageViewAware(imageView);
* @param options {@link DisplayImageOptions}
*/
public static void displayImage(final String uri, final ImageAware imageAware, final DisplayImageOptions options) {
if (imageAware != null) {
if (options != null) {
ImageLoader.getInstance().displayImage(uri, imageAware, options);
} else {
ImageLoader.getInstance().displayImage(uri, imageAware);
}
}
}
/**
* 图片显示
* @param uri Image Uri
* @param imageView ImageView
* @param listener 加载监听事件
*/
public static void displayImage(final String uri, final ImageView imageView, final ImageLoadingListener listener) {
displayImage(uri, imageView, null, listener);
}
/**
* 图片显示
* @param uri Image Uri
* @param imageView ImageView
* @param options {@link DisplayImageOptions}
* @param listener 加载监听事件
*/
public static void displayImage(final String uri, final ImageView imageView,
final DisplayImageOptions options, final ImageLoadingListener listener) {
if (imageView != null) {
if (options != null) {
ImageLoader.getInstance().displayImage(uri, imageView, options, listener);
} else {
ImageLoader.getInstance().displayImage(uri, imageView, listener);
}
}
}
/**
* 图片显示
* @param uri Image Uri
* @param imageView ImageView
* @param listener 加载监听事件
* @param progressListener 图片下载监听事件
*/
public static void displayImage(final String uri, final ImageView imageView,
final ImageLoadingListener listener,
final ImageLoadingProgressListener progressListener) {
displayImage(uri, imageView, null, listener, progressListener);
}
/**
* 图片显示
* @param uri Image Uri
* @param imageView ImageView
* @param options {@link DisplayImageOptions}
* @param listener 加载监听事件
* @param progressListener 图片下载监听事件
*/
public static void displayImage(final String uri, final ImageView imageView,
final DisplayImageOptions options, final ImageLoadingListener listener,
final ImageLoadingProgressListener progressListener) {
if (imageView != null) {
ImageLoader.getInstance().displayImage(uri, imageView, options, listener, progressListener);
}
}
// ============
// = 图片加载 =
// ============
/**
* 图片加载
* @param uri Image Uri
* @param listener 加载监听事件
*/
public static void loadImage(final String uri, final ImageLoadingListener listener) {
loadImage(uri, null, null, listener, null);
}
/**
* 图片加载
* @param uri Image Uri
* @param imageSize {@link ImageSize}
* @param listener 加载监听事件
*/
public static void loadImage(final String uri, final ImageSize imageSize, final ImageLoadingListener listener) {
loadImage(uri, imageSize, null, listener, null);
}
/**
* 图片加载
* @param uri Image Uri
* @param imageSize {@link ImageSize}
* @param listener 加载监听事件
* @param progressListener 图片下载监听事件
*/
public static void loadImage(final String uri, final ImageSize imageSize,
final ImageLoadingListener listener,
final ImageLoadingProgressListener progressListener) {
loadImage(uri, imageSize, null, listener, progressListener);
}
/**
* 图片加载
* @param uri Image Uri
* @param listener 加载监听事件
* @param progressListener 图片下载监听事件
*/
public static void loadImage(final String uri, final ImageLoadingListener listener,
final ImageLoadingProgressListener progressListener) {
loadImage(uri, null, null, listener, progressListener);
}
/**
* 图片加载
* @param uri Image Uri
* @param options {@link DisplayImageOptions}
* @param listener 加载监听事件
* @param progressListener 图片下载监听事件
*/
public static void loadImage(final String uri, final DisplayImageOptions options,
final ImageLoadingListener listener, final ImageLoadingProgressListener progressListener) {
loadImage(uri, null, options, listener, progressListener);
}
/**
* 图片加载
* @param uri Image Uri
* @param imageSize {@link ImageSize}
* @param options {@link DisplayImageOptions}
* @param listener 加载监听事件
* @param progressListener 图片下载监听事件
*/
public static void loadImage(final String uri, final ImageSize imageSize, final DisplayImageOptions options,
final ImageLoadingListener listener, final ImageLoadingProgressListener progressListener) {
ImageLoader.getInstance().loadImage(uri, imageSize, options, listener, progressListener);
}
// ================
// = 图片同步加载 =
// ================
/**
* 图片同步加载
* @param uri Image Uri
* @return {@link Bitmap}
*/
public static Bitmap loadImageSync(final String uri) {
return loadImageSync(uri, null, null);
}
/**
* 图片同步加载
* @param uri Image Uri
* @param imageSize {@link ImageSize}
* @return {@link Bitmap}
*/
public static Bitmap loadImageSync(final String uri, final ImageSize imageSize) {
return loadImageSync(uri, imageSize, null);
}
/**
* 图片同步加载
* @param uri Image Uri
* @param options {@link DisplayImageOptions}
* @return {@link Bitmap}
*/
public static Bitmap loadImageSync(final String uri, final DisplayImageOptions options) {
return loadImageSync(uri, null, options);
}
/**
* 图片同步加载
* @param uri Image Uri
* @param imageSize {@link ImageSize}
* @param options {@link DisplayImageOptions}
* @return {@link Bitmap}
*/
public static Bitmap loadImageSync(final String uri, final ImageSize imageSize, final DisplayImageOptions options) {
return ImageLoader.getInstance().loadImageSync(uri, imageSize, options);
}
// ============
// = 其他操作 =
// ============
/**
* 清除磁盘缓存
*/
public static void clearDiskCache() {
ImageLoader.getInstance().clearDiskCache();
}
/**
* 清除内存缓存
*/
public static void clearMemoryCache() {
ImageLoader.getInstance().clearMemoryCache();
}
/**
* 获取 SDCard 缓存空间
* @return {@link DiskCache}
*/
public static DiskCache getDiskCache() {
return ImageLoader.getInstance().getDiskCache();
}
/**
* 获取 Memory 缓存空间
* @return {@link MemoryCache}
*/
public static MemoryCache getMemoryCache() {
return ImageLoader.getInstance().getMemoryCache();
}
/**
* 设置是否处理弱网情况
* @param handleSlowNetwork 是否处理弱网情况
*/
public static void handleSlowNetwork(final boolean handleSlowNetwork) {
ImageLoader.getInstance().handleSlowNetwork(handleSlowNetwork);
}
/**
* 设置是否禁止网络下载
* @param denyNetworkDownloads 是否禁止网络下载
*/
public static void denyNetworkDownloads(final boolean denyNetworkDownloads) {
ImageLoader.getInstance().denyNetworkDownloads(denyNetworkDownloads);
}
// =
/**
* 取消图片显示任务
* @param imageView ImageView
*/
public static void cancelDisplayTask(final ImageView imageView) {
if (imageView != null) {
ImageLoader.getInstance().cancelDisplayTask(imageView);
}
}
/**
* 通过 ImageView 获取图片加载地址
* @param imageView ImageView
* @return Image Uri
*/
public static String getLoadingUriForView(final ImageView imageView) {
if (imageView != null) {
return ImageLoader.getInstance().getLoadingUriForView(imageView);
}
return null;
}
/**
* 设置全局加载监听事件
* @param listener 加载监听事件
*/
public static void setDefaultLoadingListener(final ImageLoadingListener listener) {
ImageLoader.getInstance().setDefaultLoadingListener(listener);
}
// =
/**
* 销毁操作
*/
public static void destroy() {
ImageLoader.getInstance().destroy();
}
/**
* 暂停图片加载
*/
public static void pause() {
ImageLoader.getInstance().pause();
}
/**
* 恢复图片加载
*/
public static void resume() {
ImageLoader.getInstance().resume();
}
/**
* 停止图片加载
*/
public static void stop() {
ImageLoader.getInstance().stop();
}
}
网友评论