Universal-Image-Loader系列2-源码分析

最新推荐文章于 2018-08-31 09:53:20 发布
最新推荐文章于 2018-08-31 09:53:20 发布
阅读量756 收藏
点赞数
分类专栏： 开源项目 文章标签： android bitmap
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mr_liabill/article/details/50382198
版权

1. 怎么实现大图片的下载，防止OOM

前面分析volley，我们知道volley并不适合大文件的下载，因为volley把输入流都写入了byte[]内存，然后写入硬盘缓存，所以容易OOM。
看UIL怎么实现大图片的下载的

    private Bitmap tryLoadBitmap() throws TaskCancelledException {
        Bitmap bitmap = null;
        try {
            File imageFile = configuration.diskCache.get(uri); //检查硬盘缓存是否保存有
            if (imageFile != null && imageFile.exists() && imageFile.length() > 0) { //有
                L.d(LOG_LOAD_IMAGE_FROM_DISK_CACHE, memoryCacheKey);
                loadedFrom = LoadedFrom.DISC_CACHE;

                checkTaskNotActual();
                bitmap = decodeImage(Scheme.FILE.wrap(imageFile.getAbsolutePath())); //从文件目录中解析，最后会调用到BaseImageDownloader的getStreamFromFile方法，从文件中获取流
            }
            if (bitmap == null || bitmap.getWidth() <= 0 || bitmap.getHeight() <= 0) { //硬盘缓存中没有，那么从网络中加载
                L.d(LOG_LOAD_IMAGE_FROM_NETWORK, memoryCacheKey);
                loadedFrom = LoadedFrom.NETWORK;

                String imageUriForDecoding = uri;
                if (options.isCacheOnDisk() && tryCacheImageOnDisk()) { //如果设置了缓存在硬盘缓存，那么调用tryCacheImageOnDisk方法把图片缓存在硬盘中
                    imageFile = configuration.diskCache.get(uri);
                    if (imageFile != null) {
                        imageUriForDecoding = Scheme.FILE.wrap(imageFile.getAbsolutePath()); //此时imageUriForDecoding字符串就是file://开头了
                    }
                }

                checkTaskNotActual();
                bitmap = decodeImage(imageUriForDecoding); //如果上面图片缓存在了硬盘file://，那么通过getStreamFromFile方法，从文件中获取流。否则http://通过getStreamFromNetwork从网络获取输入流

                if (bitmap == null || bitmap.getWidth() <= 0 || bitmap.getHeight() <= 0) {
                    fireFailEvent(FailType.DECODING_ERROR, null);
                }
            }
        } catch (IllegalStateException e) {
            fireFailEvent(FailType.NETWORK_DENIED, null);
        } catch (TaskCancelledException e) {
            throw e;
        } catch (IOException e) {
            L.e(e);
            fireFailEvent(FailType.IO_ERROR, e);
        } catch (OutOfMemoryError e) {
            L.e(e);
            fireFailEvent(FailType.OUT_OF_MEMORY, e);
        } catch (Throwable e) {
            L.e(e);
            fireFailEvent(FailType.UNKNOWN, e);
        }
        return bitmap;
    }

    //解码图片，默认解码器BaseImageDecoder
    private Bitmap decodeImage(String imageUri) throws IOException {
        ViewScaleType viewScaleType = imageAware.getScaleType();
        ImageDecodingInfo decodingInfo = new ImageDecodingInfo(memoryCacheKey, imageUri, uri, targetSize, viewScaleType,
                getDownloader(), options);
        return decoder.decode(decodingInfo);
    }

    /** @return <b>true</b> - if image was downloaded successfully; <b>false</b> - otherwise */
    private boolean tryCacheImageOnDisk() throws TaskCancelledException {
        L.d(LOG_CACHE_IMAGE_ON_DISK, memoryCacheKey);

        boolean loaded;
        try {
            loaded = downloadImage(); //下载图片，同时把图片缓存到硬盘缓存，这个方法在《监听图片下载进度怎么做到的》中有解释
            if (loaded) {
                int width = configuration.maxImageWidthForDiskCache;
                int height = configuration.maxImageHeightForDiskCache;
                if (width > 0 || height > 0) {
                    L.d(LOG_RESIZE_CACHED_IMAGE_FILE, memoryCacheKey);
                    resizeAndSaveImage(width, height); //根据设置的maxImageWidthForDiskCache，maxImageHeightForDiskCache重新裁剪保存到硬盘缓存，如果没设置那么保存的网络下载的原图
                }
            }
        } catch (IOException e) {
            L.e(e);
            loaded = false;
        }
        return loaded;
    }
    //BaseImageDecoder的解码方法
    @Override
    public Bitmap decode(ImageDecodingInfo decodingInfo) throws IOException {
        Bitmap decodedBitmap;
        ImageFileInfo imageInfo;

        InputStream imageStream = getImageStream(decodingInfo); //不同的来源不同的流，可能是文件流file://，也可能是网络流http://
        if (imageStream == null) {
            L.e(ERROR_NO_IMAGE_STREAM, decodingInfo.getImageKey());
            return null;
        }
        try {
            imageInfo = defineImageSizeAndRotation(imageStream, decodingInfo); //decodingInfo中把inJustDecodeBounds设置为true，保存有options.outWidth/outHeight
            imageStream = resetStream(imageStream, decodingInfo);
            Options decodingOptions = prepareDecodingOptions(imageInfo.imageSize, decodingInfo); //decodingInfo中有imageview的实际宽高，然后和imageInfo中计算inSampleSize缩放值，其实prepareDecodingOptions方法内部来计算了图片的ScaleType，这个就不解释了，看源码
            decodedBitmap = BitmapFactory.decodeStream(imageStream, null, decodingOptions); //根据decodingOptions中从流中解析得到最后的bitmap
        } finally {
            IoUtils.closeSilently(imageStream);
        }

        if (decodedBitmap == null) {
            L.e(ERROR_CANT_DECODE_IMAGE, decodingInfo.getImageKey());
        } else {
            decodedBitmap = considerExactScaleAndOrientatiton(decodedBitmap, decodingInfo, imageInfo.exif.rotation,
                    imageInfo.exif.flipHorizontal); //如果图片有Exif参数,那么调整该bitmap
        }
        return decodedBitmap;
    }

总结一下：
如果硬盘缓存不存在，那么先把网络下载的图片先通过流直接写入硬盘缓存，默认保存的是原图，但是如果设置了configuration.maxImageWidthForDiskCache/maxImageHeightForDiskCache就会根据这个大小进行缩放重新保存到本地硬盘，保存完之后，然后再次从硬盘缓存中读取文件输入流，此时可以计算得到Options.inSampleSize的值，生成bitmap。
此时就没有把原图写入byte[]内存，而是根据需要生成bitmap，有效的防止了OOM

2. listview,gridveiw做了哪些优化

listview等滚动中不加载图片

listView.setOnScrollListener(new PauseOnScrollListener(ImageLoader.getInstance(), pauseOnScroll, pauseOnFling)，onMyScrollListener);实现了滚动中不加载图片

    //ImageLoaderEngine方法
    void pause() {
        paused.set(true);
    }
    void resume() {
        paused.set(false);
        synchronized (pauseLock) {
            pauseLock.notifyAll();
        }
    }
    //LoadAndDisplayImageTask的run方法首先会检查是否需要被暂停
    private boolean waitIfPaused() {
        AtomicBoolean pause = engine.getPause();
        if (pause.get()) {
            synchronized (engine.getPauseLock()) {
                if (pause.get()) {
                    L.d(LOG_WAITING_FOR_RESUME, memoryCacheKey);
                    try {
                        engine.getPauseLock().wait();
                    } catch (InterruptedException e) {
                        L.e(LOG_TASK_INTERRUPTED, memoryCacheKey);
                        return true;
                    }
                    L.d(LOG_RESUME_AFTER_PAUSE, memoryCacheKey);
                }
            }
        }
        return isTaskNotActual();
    }

这样实现了滚动不加载了，滚动的时候如果调用了pause方法taskExecutor/taskExecutorForCachedImages线程池的线程，调用了wait方法，所以都被阻塞在锁池中。只有调用resume方法，notifyAll才被唤醒，所以继续执行run方法，请求bitmap
注意：只是滚动中暂停了新的请求，停止滚动了恢复请求，如果之前被加入的还会继续做请求，比如上一页已经不可见的item如果已经添加进去了，还是会去加载。暂停的只是滚动中可见的

防止listview等图片错乱闪烁重复问题

不需要手动的对imageview对setTag(url)，然后在getTag跟url判断，因为内部已经解决了这个问题
我们知道图片错乱闪烁重复问题的本质原因是异步加载及view对象被复用造成的，那么看看UIL是怎么解决这个问题的

    //ImageLoader的displayImage方法中都会把
    String memoryCacheKey = MemoryCacheUtils.generateKey(uri, targetSize);
    engine.prepareDisplayTaskFor(imageAware, memoryCacheKey);

    //ImageLoaderEngine中维护一个线程安全的Map(必须是线程安全的，因为线程池会操作这个map)，让view和memoryCacheKey一一对应
    private final Map<Integer, String> cacheKeysForImageAwares = Collections
            .synchronizedMap(new HashMap<Integer, String>());
    void prepareDisplayTaskFor(ImageAware imageAware, String memoryCacheKey) {
        cacheKeysForImageAwares.put(imageAware.getId(), memoryCacheKey);
    }

    //ViewAware的getId方法，所以只要不是同一个view，那么getId必定不同的，默认的hashcode实现是根据对象的地址来计算的，所以对象不是同一个，hashcode必然不一样
    @Override
    public int getId() {
        View view = viewRef.get();
        return view == null ? super.hashCode() : view.hashCode();
    }

    //从内存缓存/硬盘缓存/网络加载完bitmap之后，都会执行DisplayBitmapTask任务让bitmap显示在imageview上，其中会判断是否
        else if (isViewWasReused()) {
            L.d(LOG_TASK_CANCELLED_IMAGEAWARE_REUSED, memoryCacheKey);
            listener.onLoadingCancelled(imageUri, imageAware.getWrappedView());
        }
    /** Checks whether memory cache key (image URI) for current ImageAware is actual */
    private boolean isViewWasReused() {
        String currentCacheKey = engine.getLoadingUriForView(imageAware);
        return !memoryCacheKey.equals(currentCacheKey);
    }

比如此时滑到14项，但是此时复用了2项的view，那么14项和2项复用同一个imageview，所以cacheKeysForImageAwares保存的是这个view的id，还有14项的cachekey(第二项的cachekey被替换掉了)，
所以当2项网络请求完成之后，DisplayBitmapTask中imageLoadingInfo.memoryCacheKey是2项的cachekey，所以isViewWasReused返回的肯定是false，那么就不会去设置这个复用的view了，所以14项的view被正确显示为了14项的url图片，就解决了listview等图片错乱闪烁重复问题了

3. 防止同一时间点的重复请求

volley中如果添加同一个请求，那么会先请求第一个，然后再请求之后的，之后的用的肯定是硬盘缓存中的，但是这样的话就造成了imageview的闪烁，因为imageview被设置了多次。 UIL框架不会出现这个问题

    ImageLoader.getInstance().displayImage(imageUrl, uilImageview, options);
    ImageLoader.getInstance().displayImage(imageUrl, uilImageview, options);

打印结果：
D/ImageLoader: Start display image task [http://pic.nipic.com/2007-11-09/200711912453162_2.jpg_600x600]
D/ImageLoader: Start display image task [http://pic.nipic.com/2007-11-09/200711912453162_2.jpg_600x600]
D/ImageLoader: Image already is loading. Waiting… [http://pic.nipic.com/2007-11-09/200711912453162_2.jpg_600x600]
D/ImageLoader: Load image from network [http://pic.nipic.com/2007-11-09/200711912453162_2.jpg_600x600]
D/ImageLoader: Cache image on disk [http://pic.nipic.com/2007-11-09/200711912453162_2.jpg_600x600]
D/ImageLoader: Cache image in memory [http://pic.nipic.com/2007-11-09/200711912453162_2.jpg_600x600]
D/ImageLoader: Display image in ImageAware (loaded from NETWORK) [http://pic.nipic.com/2007-11-09/200711912453162_2.jpg_600x600]
D/ImageLoader: …Get cached bitmap from memory after waiting. [http://pic.nipic.com/2007-11-09/200711912453162_2.jpg_600x600]
D/ImageLoader: ImageAware is reused for another image. Task is cancelled. [http://pic.nipic.com/2007-11-09/200711912453162_2.jpg_600x600]
只会加载一个

原理：同一个时间uri相同，那么使用的就是同一个ReentrantLock

    //ImageLoaderEngine中
    private final Map<String, ReentrantLock> uriLocks = new WeakHashMap<String, ReentrantLock>();
    ReentrantLock getLockForUri(String uri) {
        ReentrantLock lock = uriLocks.get(uri);
        if (lock == null) {
            lock = new ReentrantLock();
            uriLocks.put(uri, lock);
        }
        return lock;
    }
        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(); //加锁
        try {
            ......
            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);
            }
            ......
        } catch (TaskCancelledException e) {
            fireCancelEvent();
            return;
        } finally {
            loadFromUriLock.unlock(); //释放锁
        }

        DisplayBitmapTask displayBitmapTask = new DisplayBitmapTask(bmp, imageLoadingInfo, engine, loadedFrom);
        runTask(displayBitmapTask, syncLoading, handler, engine);           
    //DisplayBitmapTask的run方法
    @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);
            //cacheKeysForImageAwares中移除了该imageAware，所以下一个请求的String currentCacheKey = engine.getLoadingUriForView(imageAware);为null，所以isViewWasReused为true
            engine.cancelDisplayTaskFor(imageAware);
            listener.onLoadingComplete(imageUri, imageAware.getWrappedView(), bitmap);
        }
    }

第二个displayimage的时候，因为使用的是同一个ReentrantLock，同时还没被释放，所以被阻塞在这里了，loadFromUriLock.unlock()之后才可以执行，然后直接从内存缓存中读取，但是此时的话DisplayBitmapTask中isViewWasReused就是true了，所以不会重新设置imageview，有效的防止重复请求闪烁问题。 但如果不是同一个view就不一样了，必须view和url同时一样。
什么时候会重新显示呢？ 那必须是DisplayBitmapTask执行完后再执行显示同一个view，url就会重新显示了

线程同步方案可以使用ReentrantLock替代synchronized，最新JDK建议这么做，effect java中也这样建议，线程同步问题提供了另一种方案

4. 内部图片下载使用了httpclient还是HttpURLConnection？

默认使用BaseImageDownloader图片下载器，可以看到内部是使用HttpURLConnection来实现的，并没有向volley一样根据api版本来分别实现

    //BaseImageDownloader中 case HTTP: case HTTPS:
    protected InputStream getStreamFromNetwork(String imageUri, Object extra) throws IOException {
        HttpURLConnection conn = createConnection(imageUri, extra);

        int redirectCount = 0;
        while (conn.getResponseCode() / 100 == 3 && redirectCount < MAX_REDIRECT_COUNT) {
            conn = createConnection(conn.getHeaderField("Location"), extra);
            redirectCount++;
        }

        InputStream imageStream;
        try {
            imageStream = conn.getInputStream();
        } catch (IOException e) {
            // Read all data to allow reuse connection (http://bit.ly/1ad35PY)
            IoUtils.readAndCloseStream(conn.getErrorStream());
            throw e;
        }
        if (!shouldBeProcessed(conn)) {
            IoUtils.closeSilently(imageStream);
            throw new IOException("Image request failed with response code " + conn.getResponseCode());
        }

        return new ContentLengthInputStream(new BufferedInputStream(imageStream, BUFFER_SIZE), conn.getContentLength());
    }
    protected HttpURLConnection createConnection(String url, Object extra) throws IOException {
        String encodedUrl = Uri.encode(url, ALLOWED_URI_CHARS);
        HttpURLConnection conn = (HttpURLConnection) new URL(encodedUrl).openConnection();
        conn.setConnectTimeout(connectTimeout);
        conn.setReadTimeout(readTimeout);
        return conn;
    }

BaseImageDownloader(Context context, int connectTimeout, int readTimeout)设置连接超时时间和读超时时间

5. 监听图片下载进度怎么做到的

怎么使用

        ImageLoader.getInstance().displayImage(imageUrl, uilImageview, options, new SimpleImageLoadingListener() {
            @Override
            public void onLoadingComplete(String imageUri, View view, Bitmap loadedImage) {
            }
        }, new ImageLoadingProgressListener() {
            @Override
            public void onProgressUpdate(String imageUri, View view, int current, int total) {
                Log.d("ImageLoader", "current:" + current + " total:" + total);
            }
        });

实现原理

只有在请求网络成功然后写入硬盘缓存的时候才会调用onProgressUpdate，原理简单来说就是把网络得到的InputStream不断的写入文件OutputStream，这个过程中监听每次写入的字节数，从而回调onProgressUpdate方法，所以如果如果图片从内存/硬盘缓存读取或者压根不写入硬盘缓存cacheOnDisk(false)，那么是不会回调onProgressUpdate
源码

    //LoadAndDisplayImageTask的downloadImage方法表示就是从网路下载图片了
    private boolean downloadImage() throws IOException {
        InputStream is = getDownloader().getStream(uri, options.getExtraForDownloader()); //发起网络请求，返回图片的InputStream
        if (is == null) {
            L.e(ERROR_NO_IMAGE_STREAM, memoryCacheKey);
            return false;
        } else {
            try {
                return configuration.diskCache.save(uri, is, this); //根据设置的硬盘缓存策略保存到硬盘，默认是LruDiskCache
            } finally {
                IoUtils.closeSilently(is);
            }
        }
    }
    //LruDiskCache的save方法
    @Override
    public boolean save(String imageUri, InputStream imageStream, IoUtils.CopyListener listener) throws IOException {
        DiskLruCache.Editor editor = cache.edit(getKey(imageUri));
        if (editor == null) {
            return false;
        }

        OutputStream os = new BufferedOutputStream(editor.newOutputStream(0), bufferSize); //buffer输出流，输出到文件
        boolean copied = false;
        try {
            copied = IoUtils.copyStream(imageStream, os, listener, bufferSize); //实际实现输入流到输出流的转换
        } finally {
            IoUtils.closeSilently(os);
            if (copied) {
                editor.commit();
            } else {
                editor.abort();
            }
        }
        return copied;
    }
    //IoUtils.copyStream方法
    public static boolean copyStream(InputStream is, OutputStream os, CopyListener listener, int bufferSize)
            throws IOException {
        int current = 0;
        int total = is.available(); //获取InputStream的总大小
        if (total <= 0) {
            total = DEFAULT_IMAGE_TOTAL_SIZE;
        }

        final byte[] bytes = new byte[bufferSize];
        int count;
        if (shouldStopLoading(listener, current, total)) return false;
        while ((count = is.read(bytes, 0, bufferSize)) != -1) {
            os.write(bytes, 0, count);
            current += count; //目前读取了的字节数
            if (shouldStopLoading(listener, current, total)) return false;
        }
        os.flush();
        return true;
    }
    //shouldStopLoading方法用来判读是否停止，可以看到这里的策略，如果比如调用了imageloader.stop()，imageview被gc回收了，此时onBytesCopied就返回true，但是如果下载进度大于75%，那就不停止写到硬盘缓存，否则停止写入硬盘缓存，这样是合理的。
    private static boolean shouldStopLoading(CopyListener listener, int current, int total) {
        if (listener != null) {
            boolean shouldContinue = listener.onBytesCopied(current, total); //回调LoadAndDisplayImageTask的onBytesCopied方法
            if (!shouldContinue) {
                if (100 * current / total < CONTINUE_LOADING_PERCENTAGE) {
                    return true; // if loaded more than 75% then continue loading anyway
                }
            }
        }
        return false;
    }
    //LoadAndDisplayImageTask方法
    @Override
    public boolean onBytesCopied(int current, int total) {
        return syncLoading || fireProgressEvent(current, total);
    }

    /** @return <b>true</b> - if loading should be continued; <b>false</b> - if loading should be interrupted */
    private boolean fireProgressEvent(final int current, final int total) {
        if (isTaskInterrupted() || isTaskNotActual()) return false; //判断是否需要停止
        if (progressListener != null) {
            Runnable r = new Runnable() {
                @Override
                public void run() {
                    progressListener.onProgressUpdate(uri, imageAware.getWrappedView(), current, total); //回调progressListener的onProgressUpdate方法
                }
            };
            runTask(r, false, handler, engine);
        }
        return true;
    }

6. 线程池管理

ImageLoaderEngine实现线程池
线程池，默认3个线程池，其中两个线程池默认3个固定线程，另一个是newCachedThreadPool线程池负责分发

    private Executor taskExecutor;
    private Executor taskExecutorForCachedImages;
    //newFixedThreadPool类型 线程池中默认3个线程
    private Executor taskDistributor;
    //newCachedThreadPool类型 excute一次runnable就开启一个线程，60s后该线程自动结束

taskDistributor用来分发的，如果硬盘缓存中有那么交给taskExecutorForCachedImages线程池，否则交给taskExecutor线程池去做网路请求
线程池阻塞队列类型FIFO, LIFO
默认FIFO，先进先出，就是说先发起请求的先处理，ImageLoaderConfiguration.tasksProcessingOrder()方法可以改变队列类型

BlockingQueue<Runnable> taskQueue = lifo ? new LIFOLinkedBlockingDeque<Runnable>() : new LinkedBlockingQueue<Runnable>();

7. 图片大小，图片scaletype的使用

硬盘缓存，缓存的是原图，除非设置了configuration.maxImageWidthForDiskCache/maxImageHeightForDiskCache，硬盘缓存的文件名，是通过FileNameGenerator根据imageUri生成的key，默认使用该uri的hashcode作为key

内存缓存，如果设置了denyCacheImageMultipleSizesInMemory，String memoryCacheKey = MemoryCacheUtils.generateKey(uri, targetSize)，那么无视了targetSize，只根据uri保存一次了。否则默认情况会就算uri一样，但是targetSize不一样的话，还是会内存缓存多次的

    protected Options prepareDecodingOptions(ImageSize imageSize, ImageDecodingInfo decodingInfo) {
        ImageScaleType scaleType = decodingInfo.getImageScaleType();
        int scale;
        if (scaleType == ImageScaleType.NONE) {
            scale = 1;
        } else if (scaleType == ImageScaleType.NONE_SAFE) {
            scale = ImageSizeUtils.computeMinImageSampleSize(imageSize);
        } else {
            ImageSize targetSize = decodingInfo.getTargetSize();
            boolean powerOf2 = scaleType == ImageScaleType.IN_SAMPLE_POWER_OF_2; //默认是IN_SAMPLE_POWER_OF_2，压缩选项是2的倍数
            scale = ImageSizeUtils.computeImageSampleSize(imageSize, targetSize, decodingInfo.getViewScaleType(), powerOf2);
        }
        if (scale > 1 && loggingEnabled) {
            L.d(LOG_SUBSAMPLE_IMAGE, imageSize, imageSize.scaleDown(scale), scale, decodingInfo.getImageKey());
        }

        Options decodingOptions = decodingInfo.getDecodingOptions();
        decodingOptions.inSampleSize = scale;
        return decodingOptions;
    }
    /**
     * srcSize(100x100), targetSize(10x10), powerOf2Scale = true -> sampleSize = 8
     * srcSize(100x100), targetSize(10x10), powerOf2Scale = false -> sampleSize = 10
     *
     * srcSize(100x100), targetSize(20x40), viewScaleType = FIT_INSIDE -> sampleSize = 5
     * srcSize(100x100), targetSize(20x40), viewScaleType = CROP       -> sampleSize = 2
     */
    public static int computeImageSampleSize(ImageSize srcSize, ImageSize targetSize, ViewScaleType viewScaleType,
            boolean powerOf2Scale) {
        final int srcWidth = srcSize.getWidth();
        final int srcHeight = srcSize.getHeight();
        final int targetWidth = targetSize.getWidth();
        final int targetHeight = targetSize.getHeight();
        int scale = 1;
        switch (viewScaleType) {
            case FIT_INSIDE: //默认，因为imageveiw的mScaleType默认是FIT_XY, 所以此时被转换为FIT_INSIDE
                if (powerOf2Scale) {
                    final int halfWidth = srcWidth / 2;
                    final int halfHeight = srcHeight / 2;
                    while ((halfWidth / scale) > targetWidth || (halfHeight / scale) > targetHeight) { // ||运算符
                        scale *= 2;
                    }
                } else {
                    scale = Math.max(srcWidth / targetWidth, srcHeight / targetHeight); // max取大
                }
                break;
            case CROP:
                if (powerOf2Scale) {
                    final int halfWidth = srcWidth / 2;
                    final int halfHeight = srcHeight / 2;
                    while ((halfWidth / scale) > targetWidth && (halfHeight / scale) > targetHeight) { // &&运算符
                        scale *= 2;
                    }
                } else {
                    scale = Math.min(srcWidth / targetWidth, srcHeight / targetHeight); // min取小
                }
                break;
        }
        if (scale < 1) { //不对原图进行放大处理(岂不是更容易OOM了)，只有压缩，inSampleSize>1 压缩
            scale = 1; 
        }
        scale = considerMaxTextureSize(srcWidth, srcHeight, scale, powerOf2Scale);

        return scale;
    }

设置为wrap_content,默认就是屏幕宽高，就是上面代码的targetSize=1080x1776
Start display image task [http://pic.nipic.com/2007-11-09/200711912453162_2.jpg_1080x1776]

举个典型的例子

        <ImageView
            android:layout_gravity="center_horizontal"
            android:id="@+id/uil_imageview"
            android:background="#ffcc0000"
            android:layout_width="150dp"
            android:layout_height="200dp"/>

原图的大小为srcSize:200*200 targetSize:450*600 所以scale=1不进行缩放，但是ImageView的scaleType的默认是FIX_XY，所以最后的显示还是会把宽放大到450，高放大到450，填不满高。居中对齐

        <ImageView
            android:layout_gravity="center_horizontal"
            android:id="@+id/uil_imageview"
            android:background="#ffcc0000"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"/>

原图的大小为srcSize:3216*2028 targetSize:1080*1776 最后scale为2，图片就会压缩两倍，生成bitmap，然后再根据imageview的默认是FIX_XY进行显示
总结： 只会对原图进行压缩不会放大，达到有效防止OOM的目的

8. 怎么处理低速网络的情况

问题描述：
http://code.google.com/p/android/issues/detail?id=6066

调用ImageLoader的handleSlowNetwork()方法，那么http/https请求就会进入SlowNetworkImageDownloader的getStream方法对imageStream进行进一步处理，return new FlushedInputStream(imageStream);具体为什么这么做，暂时也不是很清楚

9. 缺点

一定程度上没有遵从http协议，参考volley实现，硬盘缓存没有设置过期时间，volley中硬盘缓存的过期时间是根据响应头中的字段来设置的。但是UIL如果没有清空内存缓存/硬盘缓存，那么请求的图片一定不是最新的，除非displayImage的时候把DisplayImageOptions设置为cacheInMemory(false)，cacheOnDisk(false)，或者不设置这两个(默认不使用缓存)，这样使用的才是网络上最新的图片

清空缓存：
ImageLoader.getInstance().clearMemoryCache();
ImageLoader.getInstance().clearDiskCache();

Mr_LiaBin
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
universal-image-loader-1.9.5_selfsigned.jar
06-13
universal-image-loader 针对https引用了自签名证书，解决图片加载不出。
Android-Universal-Image-Loader源码解析
dapangzao的专栏
06-23 574
Android-Universal-Image-Loader 这个框架是我接触的第一个Android图片加载框架，用的比较多，因此选择这个作为第一篇源码解析的框架。 一、基本用法 1.在Application中进行init操作 /** * 初始化Universal-Image-Loader */ private void initImageLoader() { DisplayI
Android-Universal-Image-loader源码解析
左手木亽
02-19 828
Android-Universal-Image-loader作为看一款老牌的图片下载库，整体代码清晰读起来比较简易可以用来学习图片下载的功能逻辑是一个不错的选择，所以我选择解读Android-Universal-Image-loader的源码。
Universal-Image-Loader 源码的一些理解和分析
huang_xiao_yu的博客
08-31 872
这个是一个非常好用的图片加载框架，虽然作者没有再维护了，但是我们项目中还是一直在使用，并且也很稳定。既然用到了该框架，那么是时候去看看该源码和学习学习。 源码地址：https://github.com/nostra13/Android-Universal-Image-Loader 一.整体架构： 先说怎么看整个源码：我是根据下面这种图开始看的，另外，我觉得作者源码包的分类也非常明确清晰，这个...
Android-Universal-Image-Loader 源码解读
maplejaw的博客
06-15 5034
Universal-Image-Loader是一个强大而又灵活的用于加载、缓存、显示图片的Android库。它提供了大量的配置选项，使用起来非常方便。 基本概念基本使用 首次配置 在第一次使用ImageLoader时，必须初始化一个全局配置,一般会选择在Application中配置。public class MyApplication extends Application { @Overrid
Android图片异步加载框架Android-Universal-Image-Loader
08-27
主要介绍了Android图片异步加载框架Android-Universal-Image-Loader,小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
universal-image-loader-1.9.5.jar 源码 demo 源码分析
12-25
universal-image-loader-1.9.5.jar,universal-image-loader-demo.rar,Android-Universal-Image-Loader-master.zip,Android Universal Image Loader 源码分析.doc
Android-Universal-Image-Loader-master.zip
04-12
Android-Universal-Image-Loader框架
全面解析Android的开源图片框架Universal-Image-Loader
09-02
主要介绍了Android的开源图片框架Universal-Image-Loader,Universal-Image-Loader在GitHub上开源,其提供的图片加载功能令人印象相当深刻,需要的朋友可以参考下
Android 内存泄漏检查工具LeakCanary源碼浅析
Mr_LiaBill
01-23 5635
使用参考我之前写的《Android 内存泄漏工具使用》监控 Activity 泄露我们经常把 Activity 当作为 Context 对象使用，在不同场合由各种对象引用 Activity。所以，Activity 泄漏是一个重要的需要检查的内存泄漏之一。public class ExampleApplication extends Application { public static Re
Volley框架之三 疑难实现
Mr_LiaBill
12-09 2589
有了前面两章做基础，这篇文章主要分析一下，从Volley中我学到的知识点问题1： Requset是在哪里处理的？主线程还是子线程？ 子线程处理Request，只要new了一个RequestQueue那么就会开启1个缓存线程，4个网络请求线程，CacheDispatcher/NetworkDispatcher继承自Thread。 这就意味着一次最多只能并发5个线程，如果缓存线程没有命中，那么最多并
Android 注解工具ButterKnife源码分析
Mr_LiaBill
01-22 1730
Java注解Annotation参考 公共技术点之 Java 注解 Annotation归纳总结一下：作用a. 标记，用于告诉编译器一些信息 @Override就是，如果没有正确重载方法，编译不过 b. 编译时动态处理，如动态生成代码 ButterKnife就是此类 c. 运行时动态处理，如得到注解信息 用的比较少，运行时可通过Method.getAnnotation方法得到运行时注解信息
Android 开源项目NineOldAnimations详解
Mr_LiaBill
01-13 1175
背景常见的属性动画属性: alpha 透明度 scaleX 缩放X方向 scaleY 缩放Y方向 translationX 平移X方向 translationY 平移Y方向 rotation 旋转 rotationX X轴翻转 rotationY Y轴翻转 pivotX 设置旋转，翻转效果中心x坐标 (默认是在view的中心x坐标) pivotY 设置旋转，翻转效果中心y坐标
个人开源项目 第三方Git@OSC客户端
Mr_LiaBill
09-12 934
本人GitHub:  https://github.com/BinJing 本产品是Git@OSC第三方客户端，遵循Material Design设计原则。参考官方客户端地址：http://http://git.oschina.net/appclient 本客户端相比官方客户端特色如下 界面采取Material Design设计风格使用android suppor
Universal-Image-Loader系列1-配置使用
Mr_LiaBill
12-22 869
Android-Universal-Image-Loader官方使用介绍，参考 wiki默认值ImageLoaderConfiguration全局显示选项/* ImageLoader Configuration (ImageLoaderConfiguration) is global for application. You should set it once. All options in C
Android 开源项目EventBus详解
Mr_LiaBill
12-27 814
使用//MainActivity public class MainActivity extends FragmentActivity { @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setConte
Volley框架之一 如何使用
Mr_LiaBill
12-08 802
一直想找个优秀的开源框架学习下，Volley非常合适，研究下来学到了不少知识Volley简介Volley可是说是把AsyncHttpClient和Universal-Image-Loader的优点集于了一身，既可以像AsyncHttpClient一样非常简单地进行HTTP通信，也可以像Universal-Image-Loader一样轻松加载网络上的图片。除了简单易用之外，Volley在性能方面也进行
Volley框架之四 加载网络图片
Mr_LiaBill
12-09 714
使用Volley去加载图片的方式前面已经介绍了，有三种方式，下面主要介绍ImageRequest方式和ImageLoader方式的区别和联系ImageRequest看一下源代码，主要就是parseNetworkResponse方法的实现，解析网络返回的response /** Decoding lock so that we don't decode more than one image a
universal-image-loader
最新发布
06-10
Universal Image Loader是一个用于Android应用程序中异步加载和缓存图像的库。它可以从本地文件系统或网络URL中异步加载图像，并提供了各种选项来优化图像加载和缓存的性能。它支持从网络上下载图片并缓存在本地，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值