Android ImageLoader 工具類

DevUtils Github

• ImageLoader 工具類 -> ImageLoaderUtils.java

方法	註釋
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();
    }
}