史上最全Universal-Image-Loader原始碼解析————核心程式碼篇
阿新 • • 發佈：2019-01-04
背景
接著上一篇的內容，我們接著看ImageLoader的核心程式碼篇，上一篇主要是看ImageLoader的記憶體優化，主要包括磁碟快取和記憶體快取，還有就是記憶體的快取策略，這一篇，我們重點來看一下ImageLoader是如何使用這些記憶體和進行圖片的展示和圖片處理和下載的。
一、code組織框架
首先我們先看code包下面的組織框架，然後我們再每個類去分析，最後我們全部串起來學習。核心程式碼篇和上一篇快取篇不一樣，核心程式碼量較多，但是我們部落格篇幅有限，我們只能按重要程度，將大部分進行講解，不多說先上截圖。
二 、詳細程式碼及類講解
（1）ImageLoader
這個類可能是開發者最先接觸或者說印象最深刻的類了，我們來看一下我們是怎麼接觸它的，我們來看一下它的最簡單使用和原始碼的實現。
//建立預設的ImageLoader配置引數
ImageLoaderConfiguration configuration = ImageLoaderConfiguration
.createDefault(this);
ImageLoader.getInstance().init(configuration);
ImageLoader.getInstance().displayImage /**
* ImageLoader是核心主類之一
*/
public class ImageLoader {
public static final String TAG = ImageLoader.class.getSimpleName();
static final String LOG_INIT_CONFIG = "Initialize ImageLoader with configuration";
static final String LOG_DESTROY = "Destroy ImageLoader" （2）DefaultConfigurationFactory
這個類是一個使用工廠模式方法提供一個隊imageloader的引數配置，通過這個類，可以建立一系列的配置引數，通過程式碼我們可以清楚的看到，它預設使用hashcode的磁碟命名，如果磁碟沒有傳大小，那麼就會使用無限的磁碟快取策略，如果有傳大小的話，那麼就使用最近最少使用的磁碟快取策略，記憶體快取的話，如果有傳大小，那麼使用這個傳的大小，如果沒有穿引數的話，那麼就使用app最大的八分之一，使用最近最少快取策略，還有就是建立一些圖片展示器之類的。
/**
* Factory for providing of default options for {@linkplain ImageLoaderConfiguration configuration}
*一個工廠提供預設的操作對imageloader的引數
* @author Sergey Tarasevich (nostra13[at]gmail[dot]com)
* @since 1.5.6
*/
public class DefaultConfigurationFactory {
/** 建立一個預設的執行器 */
public static Executor createExecutor(int threadPoolSize, int threadPriority,
QueueProcessingType tasksProcessingType) {
boolean lifo = tasksProcessingType == QueueProcessingType.LIFO;
BlockingQueue<Runnable> taskQueue =
lifo ? new LIFOLinkedBlockingDeque<Runnable>() : new LinkedBlockingQueue<Runnable>();
return new ThreadPoolExecutor(threadPoolSize, threadPoolSize, 0L, TimeUnit.MILLISECONDS, taskQueue,
createThreadFactory(threadPriority, "uil-pool-"));
}
/** /預設的任務分發Executor */
public static Executor createTaskDistributor() {
return Executors.newCachedThreadPool(createThreadFactory(Thread.NORM_PRIORITY, "uil-pool-d-"));
}
/**預設的磁碟快取檔名的生成策略 */
public static FileNameGenerator createFileNameGenerator() {
return new HashCodeFileNameGenerator();
}
/**
* 預設的硬體快取配置 如果值為0的話就用無限的磁碟快取 如果大於0就用最近最少使用快取
*/
public static DiskCache createDiskCache(Context context, FileNameGenerator diskCacheFileNameGenerator,
long diskCacheSize, int diskCacheFileCount) {
File reserveCacheDir = createReserveDiskCacheDir(context);
if (diskCacheSize > 0 || diskCacheFileCount > 0) {
File individualCacheDir = StorageUtils.getIndividualCacheDirectory(context);
try {
return new LruDiskCache(individualCacheDir, reserveCacheDir, diskCacheFileNameGenerator, diskCacheSize,
diskCacheFileCount);
} catch (IOException e) {
L.e(e);
// continue and create unlimited cache
}
}
File cacheDir = StorageUtils.getCacheDirectory(context);
return new UnlimitedDiskCache(cacheDir, reserveCacheDir, diskCacheFileNameGenerator);
}
/** Creates reserve disk cache folder which will be used if primary disk cache folder becomes unavailable */
private static File createReserveDiskCacheDir(Context context) {//預設的備用硬體快取目錄
File cacheDir = StorageUtils.getCacheDirectory(context, false);
File individualDir = new File(cacheDir, "uil-images");
if (individualDir.exists() || individualDir.mkdir()) {
cacheDir = individualDir;
}
return cacheDir;
}
/**
* Creates default implementation of {@link MemoryCache} - {@link LruMemoryCache}<br />
* Default cache size = 1/8 of available app memory.
*
* 配置 如果傳入的預設大小為0 那麼就拿到App最大記憶體的八分之一
* 如果不為0 那麼就用傳入的大小來作為最近最少使用演算法的記憶體
*/
public static MemoryCache createMemoryCache(Context context, int memoryCacheSize) {
if (memoryCacheSize == 0) {
ActivityManager am = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
int memoryClass = am.getMemoryClass();
if (hasHoneycomb() && isLargeHeap(context)) {
memoryClass = getLargeMemoryClass(am);
}
memoryCacheSize = 1024 * 1024 * memoryClass / 8;
}
return new LruMemoryCache(memoryCacheSize);
}
private static boolean hasHoneycomb() {
return Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB;
}
@TargetApi(Build.VERSION_CODES.HONEYCOMB)
private static boolean isLargeHeap(Context context) {
return (context.getApplicationInfo().flags & ApplicationInfo.FLAG_LARGE_HEAP) != 0;
}
//
@TargetApi(Build.VERSION_CODES.HONEYCOMB)
private static int getLargeMemoryClass(ActivityManager am) {
return am.getLargeMemoryClass();
}
//建立一個圖片下載器
/** Creates default implementation of {@link ImageDownloader} - {@link BaseImageDownloader} */
public static ImageDownloader createImageDownloader(Context context) {
return new BaseImageDownloader(context);
}
//建立一個圖片修改器
/** Creates default implementation of {@link ImageDecoder} - {@link BaseImageDecoder} */
public static ImageDecoder createImageDecoder(boolean loggingEnabled) {
return new BaseImageDecoder(loggingEnabled);
}
//預設的BitmapDisplayer
/** Creates default implementation of {@link BitmapDisplayer} - {@link SimpleBitmapDisplayer} */
public static BitmapDisplayer createBitmapDisplayer() {
return new SimpleBitmapDisplayer();
}
//預設的TreadFactory
/** Creates default implementation of {@linkplain ThreadFactory thread factory} for task executor */
private static ThreadFactory createThreadFactory(int threadPriority, String threadNamePrefix) {
return new DefaultThreadFactory(threadPriority, threadNamePrefix);
}
private static class DefaultThreadFactory implements ThreadFactory {
private static final AtomicInteger poolNumber = new AtomicInteger(1);
private final ThreadGroup group;
private final AtomicInteger threadNumber = new AtomicInteger(1);
private final String namePrefix;
private final int threadPriority;
DefaultThreadFactory(int threadPriority, String threadNamePrefix) {
this.threadPriority = threadPriority;
group = Thread.currentThread().getThreadGroup();
namePrefix = threadNamePrefix + poolNumber.getAndIncrement() + "-thread-";
}
@Override
public Thread newThread(Runnable r) {
Thread t = new Thread(group, r, namePrefix + threadNumber.getAndIncrement(), 0);
if (t.isDaemon()) t.setDaemon(false);
t.setPriority(threadPriority);
return t;
}
}
}（3）DisplayBitmapTask
一個顯示圖片任務的類，開了一個子執行緒實現Runnable介面，主要是run的一個判斷，註解才是重點
/**
*顯示圖片任務的一個類
*/
final class DisplayBitmapTask implements Runnable {
private static final String LOG_DISPLAY_IMAGE_IN_IMAGEAWARE = "Display image in ImageAware (loaded from %1$s) [%2$s]";
private static final String LOG_TASK_CANCELLED_IMAGEAWARE_REUSED = "ImageAware is reused for another image. Task is cancelled. [%s]";
private static final String LOG_TASK_CANCELLED_IMAGEAWARE_COLLECTED = "ImageAware was collected by GC. Task is cancelled. [%s]";
private final Bitmap bitmap;
private final String imageUri;//
private final ImageAware imageAware;//
private final String memoryCacheKey;
private final BitmapDisplayer displayer;
private final ImageLoadingListener listener;
private final ImageLoaderEngine engine;
private final LoadedFrom loadedFrom;
//初始化
public DisplayBitmapTask(Bitmap bitmap, ImageLoadingInfo imageLoadingInfo, ImageLoaderEngine engine,
LoadedFrom loadedFrom) {
this.bitmap = bitmap;
imageUri = imageLoadingInfo.uri;
imageAware = imageLoadingInfo.imageAware;
memoryCacheKey = imageLoadingInfo.memoryCacheKey;
displayer = imageLoadingInfo.options.getDisplayer();
listener = imageLoadingInfo.listener;
this.engine = engine;
this.loadedFrom = loadedFrom;
}
@Override
public void run() {
if (imageAware.isCollected()) {//判斷圖片View是否已經被回收了，如果已經被回收，則取消任務
L.d(LOG_TASK_CANCELLED_IMAGEAWARE_COLLECTED, memoryCacheKey);
listener.onLoadingCancelled(imageUri, imageAware.getWrappedView());
} else if (isViewWasReused()) {//圖片View是否又用來展示其他圖片了，如果是的話，則取消任務
L.d(LOG_TASK_CANCELLED_IMAGEAWARE_REUSED, memoryCacheKey);
listener.onLoadingCancelled(imageUri, imageAware.getWrappedView());
} else {//展示圖片 完成介面回撥
L.d(LOG_DISPLAY_IMAGE_IN_IMAGEAWARE, loadedFrom, memoryCacheKey);
displayer.display(bitmap, imageAware, loadedFrom);
engine.cancelDisplayTaskFor(imageAware);
listener.onLoadingComplete(imageUri, imageAware.getWrappedView(), bitmap);
}
}
/** 檢查imageview是否有效 */
private boolean isViewWasReused() {
String currentCacheKey = engine.getLoadingUriForView(imageAware);
return !memoryCacheKey.equals(currentCacheKey);
}
}（4）DisplayImageOptions
展示圖片的一個引數操作，展示的時候傳入引數，展示的圖片會根據傳入的引數進行展示。
/**
* 展示圖片的一個引數操作
*/
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;
}
//空uri的時候是否需要顯示圖片
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;
}
//是否重置view
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}
*/
public static class Builder {
private int imageResOnLoading = 0; //在圖片下載期間顯示的圖片
private int imageResForEmptyUri = 0;//設定圖片Uri為空或是錯誤的時候顯示的圖片
private int imageResOnFail = 0; //設定圖片載入/解碼過程中錯誤時候顯示的圖片
private Drawable imageOnLoading = null;//在圖片下載期間顯示的圖片
private Drawable imageForEmptyUri = null;//設定圖片Uri為空或是錯誤的時候顯示的圖片
private Drawable imageOnFail = null;//設定圖片載入/解碼過程中錯誤時候顯示的圖片
private boolean resetViewBeforeLoading = false; //設定圖片在下載前是否重置，復位
private boolean cacheInMemory = false;//設定下載的圖片是否快取在記憶體中
private boolean cacheOnDisk = false; //設定下載的圖片是否快取在SD卡中
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;//設定額外的內容給ImageDownloade
private BitmapProcessor preProcessor = null;//設定圖片加入快取前，對bitmap進行設定
private BitmapProcessor postProcessor = null; //設定顯示前的圖片，顯示後這個圖片一直保留在快取中
private BitmapDisplayer displayer = DefaultConfigurationFactory.createBitmapDisplayer();
private Handler handler = null;
private boolean isSyncLoading = false;
/**
* 設定引數欄位參考上面註釋
*/
@Deprecated
public Builder showStubImage(int imageRes) {
imageResOnLoading = imageRes;
return this;
}
/**
* 設定引數欄位參考上面註釋
*/
public Builder showImageOnLoading(int imageRes) {
imageResOnLoading = imageRes;
return this;
}
/**
* 設定引數欄位參考上面註釋
*/
public Builder showImageOnLoading(Drawable drawable) {
imageOnLoading = drawable;
return this;
}
/**
* 設定引數欄位參考上面註釋
*/