/** * 加载图片工具类 * @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 void display(T container, String uri) { display(container, uri, null, null); } /** * 根据图片路径，显示到具体的View上 * @param container 要把图片显示到的View * @param uri 图片路径 * @param displayConfig */ public void display(T container, String uri, BitmapDisplayConfig displayConfig) { display(container, uri, displayConfig, null); } /** * 根据图片路径，显示到具体的View上 * @param container 要把图片显示到的View * @param uri 图片路径 * @param callBack 加载过程回调各种状态 */ public void display(T container, String uri, BitmapLoadCallBack callBack) { display(container, uri, null, callBack); } /** * 根据图片路径，显示到具体的View上 * @param container 要把图片显示到的View * @param uri 图片路径 * @param displayConfig 位图显示配置 * @param callBack */ public void display(T container, String uri, BitmapDisplayConfig displayConfig, BitmapLoadCallBack callBack) { if (container == null) { return; } if (callBack == null) { callBack = new DefaultBitmapLoadCallBack (); } 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 loadTask = new BitmapLoadTask (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 (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 BitmapLoadTask getBitmapTaskFromContainer(T container, BitmapLoadCallBack callBack) { if (container != null) { final Drawable drawable = callBack.getDrawable(container); if (drawable instanceof AsyncDrawable) { final AsyncDrawable asyncDrawable = (AsyncDrawable ) drawable; return asyncDrawable.getBitmapWorkerTask(); } } return null; } private static boolean bitmapLoadTaskExist(T container, String uri, BitmapLoadCallBack callBack) { final BitmapLoadTask 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 extends PriorityAsyncTask { private final String uri; private final WeakReference containerReference; private final BitmapLoadCallBack callBack; private final BitmapDisplayConfig displayConfig; private BitmapLoadFrom from = BitmapLoadFrom.DISK_CACHE; public BitmapLoadTask(T container, String uri, BitmapDisplayConfig config, BitmapLoadCallBack callBack) { if (container == null || uri == null || config == null || callBack == null) { throw new IllegalArgumentException("args may not be null"); } this.containerReference = new WeakReference (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 bitmapWorkerTask = getBitmapTaskFromContainer(container, callBack); if (this == bitmapWorkerTask) { return container; } return null; } }}