universal-image-loader源码解析

最新推荐文章于 2019-01-20 11:36:45 发布

KANDJBO

最新推荐文章于 2019-01-20 11:36:45 发布

阅读量268

点赞数

分类专栏： Android

本文链接：https://blog.csdn.net/qq_35664307/article/details/72612196

版权

Android 专栏收录该内容

19 篇文章 0 订阅

订阅专栏

一.执行流程:
首先我们是配置好configuration和displayOptions,然后进入到displayImage方法里来.
1.检查缓存里是否有图片
2.没有的话,将传进来的参数与option一起包装成ImageloadingInfo类
3.传入LoadAndDisplayImage里通过Engine类进行加载执行.
5.在LoadAndDisplayImage类里的tryloadImage方法里,我们可以看到这个ImageloadingInfo再次被包装成ImageDecodingInfo传入ImageDecoder里.
6.ImageDecoder将信息传到ImageDownloader里,进行下载.
7.下载完成后或者解码完图片后,再把它放到Imageaware里进行显示.
8.但真正的显示是BitmapDisplay类来执行的.

二.类功能大体分析(详细分析后面会写)
1.cache文件:缓存策略的实现
2.ImageLoaderConfiguration:一些配置信息,主要是对线程的限制.
3.DefaultConfigurationFactory:使用工厂方法模式实现的默认的配置信息.
4.DisplayImageOptions:顾名思义啊,就是图片显示时你要对它做的一些要求.
5.ImageLoadingInfo:对options和一些值进行包装的一个数据类.
6.三个Task类:runnable的实现类,用于图片的耗时操作.
7.process文件夹:可以用它的接口来自定义对图片的处理.
8.listener文件夹:用于监听事件,并作出处理,还有进度条的监听.
9.Imageaware文件夹+display文件夹:对图片的显示进行处理.
10.decode:对获取到的图片进行解码处理,返回一个bitmap.
11.download:对uri进行加载,并获取到inputstream,返回给decode.
12.assist:一些enum类,还有对输入流作出一些自定义操作的类.还有自定义了一些双向队列.

三.详细分析:
从Imageloader类里的DisplayImage方法,我们可以跟踪得到它的执行过程:

public void displayImage(String uri, ImageAware imageAware, DisplayImageOptions options,
            ImageSize targetSize, ImageLoadingListener listener, ImageLoadingProgressListener progressListener) {
        checkConfiguration();
        if (imageAware == null) {
            throw new IllegalArgumentException(ERROR_WRONG_ARGUMENTS);
        }
        if (listener == null) {
            listener = defaultListener;
        }
        if (options == null) {
            options = configuration.defaultDisplayImageOptions;
        }

        if (TextUtils.isEmpty(uri)) {
            engine.cancelDisplayTaskFor(imageAware);
            listener.onLoadingStarted(uri, imageAware.getWrappedView());
            if (options.shouldShowImageForEmptyUri()) {
                imageAware.setImageDrawable(options.getImageForEmptyUri(configuration.resources));
            } else {
                imageAware.setImageDrawable(null);
            }
            listener.onLoadingComplete(uri, imageAware.getWrappedView(), null);
            return;
        }

        if (targetSize == null) {
            targetSize = ImageSizeUtils.defineTargetSizeForView(imageAware, configuration.getMaxImageSize());
        }
        String memoryCacheKey = MemoryCacheUtils.generateKey(uri, targetSize);
        engine.prepareDisplayTaskFor(imageAware, memoryCacheKey);

        listener.onLoadingStarted(uri, imageAware.getWrappedView());

        Bitmap bmp = configuration.memoryCache.get(memoryCacheKey);
        if (bmp != null && !bmp.isRecycled()) {
            L.d(LOG_LOAD_IMAGE_FROM_MEMORY_CACHE, memoryCacheKey);

            if (options.shouldPostProcess()) {
                ImageLoadingInfo imageLoadingInfo = new ImageLoadingInfo(uri, imageAware, targetSize, memoryCacheKey,
                        options, listener, progressListener, engine.getLockForUri(uri));
                ProcessAndDisplayImageTask displayTask = new ProcessAndDisplayImageTask(engine, bmp, imageLoadingInfo,
                        defineHandler(options));
                if (options.isSyncLoading()) {
                    displayTask.run();
                } else {
                    engine.submit(displayTask);
                }
            } else {
                options.getDisplayer().display(bmp, imageAware, LoadedFrom.MEMORY_CACHE);
                listener.onLoadingComplete(uri, imageAware.getWrappedView(), bmp);
            }
        } else {
            if (options.shouldShowImageOnLoading()) {
                imageAware.setImageDrawable(options.getImageOnLoading(configuration.resources));
            } else if (options.isResetViewBeforeLoading()) {
                imageAware.setImageDrawable(null);
            }

            ImageLoadingInfo imageLoadingInfo = new ImageLoadingInfo(uri, imageAware, targetSize, memoryCacheKey,
                    options, listener, progressListener, engine.getLockForUri(uri));
            LoadAndDisplayImageTask displayTask = new LoadAndDisplayImageTask(engine, imageLoadingInfo,
                    defineHandler(options));
            if (options.isSyncLoading()) {
                displayTask.run();
            } else {
                engine.submit(displayTask);
            }
        }
    }

这个方法的执行过程大体就是
1.判断相应的配置信息是否为空2.从内存中获取图片,得到并进入processandDisplayImage类中对图片进行处理3.在内存中无图片,进入loadAndDisplayImage类中执行.
因为Imageloader使用的是门面模式,它很好的反应了流程,但是具体的执行细节,还要进入具体类.从上面的方法中,我们可以发现ImageLoadEngine类和loadAndDisplayImage类和processandDisplayImage类出现.
ImageLoadEngine类如下: 类中有三个Executor变量,可见是要对相关的线程进行执行.从displayImage方法里看到有engine.submit(displayTask)这句.在ImageLoaderEngine类的submit方法中,我们看到就是单纯的Executor对task(实际为Runnable)的执行.所以此类是一个执行类,我们继续深入到loadAndDisplayImage类中.

private Executor taskExecutor;//用于加载图片
private Executor taskExecutorForCachedImages;//用于处理图片
private Executor taskDistributor;//用于分发
void submit(final LoadAndDisplayImageTask task) {
    taskDistributor.execute(new Runnable() {
        @Override
        public void run() {
            File image = configuration.diskCache.get(task.getLoadingUri());
            boolean isImageCachedOnDisk = image != null && image.exists();
            initExecutorsIfNeed();
            if (isImageCachedOnDisk) {
                taskExecutorForCachedImages.execute(task);
            } else {
                taskExecutor.execute(task);
            }
        }
    });
}

/** Submits task to execution pool */
void submit(ProcessAndDisplayImageTask task) {
    initExecutorsIfNeed();
    taskExecutorForCachedImages.execute(task);
}

loadAndDisplayImage类主要代码如下:
这个类才是真正的应用三级缓存对图片进行加载操作的类,先看是否在内存中有,没有就进入diskCache中,再没有才进行网络的下载,将下载好的图片再放入到diskCache中,再从中获取.当没有在内存和diskCache中找到图片时,我们回去网络加载,所以就得再深入到ImageDecoder类中了.

@Override
public void run() {
    if (waitIfPaused()) return;
    if (delayIfNeed()) return;

    ReentrantLock loadFromUriLock = imageLoadingInfo.loadFromUriLock;
    L.d(LOG_START_DISPLAY_IMAGE_TASK, memoryCacheKey);
    if (loadFromUriLock.isLocked()) {
        L.d(LOG_WAITING_FOR_IMAGE_LOADED, memoryCacheKey);
    }

    loadFromUriLock.lock();
    Bitmap bmp;
    try {
        checkTaskNotActual();

        bmp = configuration.memoryCache.get(memoryCacheKey);
        if (bmp == null || bmp.isRecycled()) {
            bmp = tryLoadBitmap();
            if (bmp == null) return; // listener callback already was fired
                checkTaskNotActual();
                checkTaskInterrupted();

                if (options.shouldPreProcess()) {
                    L.d(LOG_PREPROCESS_IMAGE, memoryCacheKey);
                    bmp = options.getPreProcessor().process(bmp);
                    if (bmp == null) {
                    L.e(ERROR_PRE_PROCESSOR_NULL, memoryCacheKey);
                }
            }

            if (bmp != null && options.isCacheInMemory()) {
                L.d(LOG_CACHE_IMAGE_IN_MEMORY, memoryCacheKey);
                configuration.memoryCache.put(memoryCacheKey, bmp);
            }
        } else {
            loadedFrom = LoadedFrom.MEMORY_CACHE;
            L.d(LOG_GET_IMAGE_FROM_MEMORY_CACHE_AFTER_WAITING, memoryCacheKey);
        }

        if (bmp != null && options.shouldPostProcess()) {
            L.d(LOG_POSTPROCESS_IMAGE, memoryCacheKey);
            bmp = options.getPostProcessor().process(bmp);
            if (bmp == null) {
                L.e(ERROR_POST_PROCESSOR_NULL, memoryCacheKey);
            }
        }
        checkTaskNotActual();
        checkTaskInterrupted();
    } catch (TaskCancelledException e) {
        fireCancelEvent();
        return;
    } finally {
        loadFromUriLock.unlock();
    }

    DisplayBitmapTask displayBitmapTask = new DisplayBitmapTask(bmp, imageLoadingInfo, engine, loadedFrom);
    runTask(displayBitmapTask, syncLoading, handler, engine);
}

ImageDecoder类实际为一个接口,可以看到ImageDecodingInfo 是一个对要解码的对象进行包装的类,ImageDecoder类的具体实现类如下:

public interface ImageDecoder {
    Bitmap decode(ImageDecodingInfo imageDecodingInfo) throws IOException;
}

BaseImageDecoder:
(解释在注释里)

public Bitmap decode(ImageDecodingInfo decodingInfo) throws IOException {
        Bitmap decodedBitmap;
    ImageFileInfo imageInfo;
        //得到InputStream,通过ImageDownLoader的getStream方法,下面会介绍.
    InputStream imageStream = getImageStream(decodingInfo);
    if (imageStream == null) {
        L.e(ERROR_NO_IMAGE_STREAM, decodingInfo.getImageKey());
        return null;
    }
    try {
            //返回下载后的图片的宽高,还未经处理.
        imageInfo = defineImageSizeAndRotation(imageStream, decodingInfo);
        //重置InputStream
        imageStream = resetStream(imageStream, decodingInfo);
        //根据加载后的图片的宽高与客户的要求对图片进行处理,获得缩放比,并存入options中返回.
        Options decodingOptions = prepareDecodingOptions(imageInfo.imageSize, decodingInfo);
        //解码.
        decodedBitmap = BitmapFactory.decodeStream(imageStream, null, decodingOptions);
    } finally {
        IoUtils.closeSilently(imageStream);
    }

    if (decodedBitmap == null) {
        L.e(ERROR_CANT_DECODE_IMAGE, decodingInfo.getImageKey());
    } else {
        decodedBitmap = considerExactScaleAndOrientatiton(decodedBitmap, decodingInfo, imageInfo.exif.rotation,
        mageInfo.exif.flipHorizontal);
    }
    return decodedBitmap;
}

上面说到还有一个加载类ImageDownLoader类:
它的内部使用HttpURLConnection进行图片的下载.

public interface ImageDownloader {
    InputStream getStream(String imageUri, Object extra) throws IOException;
}

现在图片也下载好了,总得让它显示吧.
在上面的loadAndDisplayImageTask的run方法最后有一段这样的代码,可见DisplayBitmapTask 应该就是显示任务的线程类了.

DisplayBitmapTask displayBitmapTask = new DisplayBitmapTask(bmp, imageLoadingInfo, engine, loadedFrom);
runTask(displayBitmapTask, syncLoading, handler, engine);

DisplayBitmapTask 类如下:
看这句 displayer.display(bitmap, imageAware, loadedFrom); BitmapDisplayer就是显示类.

@Override
public void run() {
    if (imageAware.isCollected()) {
        L.d(LOG_TASK_CANCELLED_IMAGEAWARE_COLLECTED, memoryCacheKey);
        listener.onLoadingCancelled(imageUri, imageAware.getWrappedView());
    } else if (isViewWasReused()) {
        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);
    }
}

来看BitmapDisplayer类: 一个接口.

public interface BitmapDisplayer {
    void display(Bitmap bitmap, ImageAware imageAware, LoadedFrom loadedFrom);
}

这里就不对它的实现类进行分析了,这里可以继承它,并且在图片显示的时候,让它进行个性化的显示,比如说将图片显示成圆形的等.
最后了,得有个容器装bitmap吧,不然bitmap在什么上显示了,至少也得在ImageView上吧.
作者对ImageView进行包装, 使用弱引用,可以对其进行回收,在ViewAware虚类中有.

public abstract class ViewAware implements ImageAware {
    protected Reference<View> viewRef;
}

ImageAware接口,具体的实现类是ImageViewAware,主要实现setImageDrawable和setImageBitmap这俩个方法.isCollected()方法判断view是否被回收.

public interface ImageAware {
    int getWidth();
    int getHeight();
    ViewScaleType getScaleType();
    View getWrappedView();
    boolean isCollected();
    int getId()
    boolean setImageDrawable(Drawable drawable);
    boolean setImageBitmap(Bitmap bitmap);
}