提问



我使用ListView来显示与这些图像相关的一些图像和标题。我从互联网上获取图像。有没有办法延迟加载图像,以便文本显示时,UI不会被锁定,图像会在下载时显示?


图像总数不固定。

最佳参考


这是我创建的用于保存我的应用程序当前正在显示的图像。请注意,此处使用的Log对象是我在Android内部最终Log类的自定义包装器。


package com.wilson.android.library;

/*
 Licensed to the Apache Software Foundation (ASF) under one
or more contributor license agreements.  See the NOTICE file
distributed with this work for additional information
regarding copyright ownership.  The ASF licenses this file
to you under the Apache License, Version 2.0 (the
"License"); you may not use this file except in compliance
with the License.  You may obtain a copy of the License at

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing,
software distributed under the License is distributed on an
"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
KIND, either express or implied.  See the License for the
specific language governing permissions and limitations
under the License.
*/
import java.io.IOException;

public class DrawableManager {
    private final Map<String, Drawable> drawableMap;

    public DrawableManager() {
        drawableMap = new HashMap<String, Drawable>();
    }

    public Drawable fetchDrawable(String urlString) {
        if (drawableMap.containsKey(urlString)) {
            return drawableMap.get(urlString);
        }

        Log.d(this.getClass().getSimpleName(), "image url:" + urlString);
        try {
            InputStream is = fetch(urlString);
            Drawable drawable = Drawable.createFromStream(is, "src");


            if (drawable != null) {
                drawableMap.put(urlString, drawable);
                Log.d(this.getClass().getSimpleName(), "got a thumbnail drawable: " + drawable.getBounds() + ", "
                        + drawable.getIntrinsicHeight() + "," + drawable.getIntrinsicWidth() + ", "
                        + drawable.getMinimumHeight() + "," + drawable.getMinimumWidth());
            } else {
              Log.w(this.getClass().getSimpleName(), "could not get thumbnail");
            }

            return drawable;
        } catch (MalformedURLException e) {
            Log.e(this.getClass().getSimpleName(), "fetchDrawable failed", e);
            return null;
        } catch (IOException e) {
            Log.e(this.getClass().getSimpleName(), "fetchDrawable failed", e);
            return null;
        }
    }

    public void fetchDrawableOnThread(final String urlString, final ImageView imageView) {
        if (drawableMap.containsKey(urlString)) {
            imageView.setImageDrawable(drawableMap.get(urlString));
        }

        final Handler handler = new Handler() {
            @Override
            public void handleMessage(Message message) {
                imageView.setImageDrawable((Drawable) message.obj);
            }
        };

        Thread thread = new Thread() {
            @Override
            public void run() {
                //TODO : set imageView to a "pending" image
                Drawable drawable = fetchDrawable(urlString);
                Message message = handler.obtainMessage(1, drawable);
                handler.sendMessage(message);
            }
        };
        thread.start();
    }

    private InputStream fetch(String urlString) throws MalformedURLException, IOException {
        DefaultHttpClient httpClient = new DefaultHttpClient();
        HttpGet request = new HttpGet(urlString);
        HttpResponse response = httpClient.execute(request);
        return response.getEntity().getContent();
    }
}

其它参考1


我用图像做了一个懒惰列表(位于GitHub)的简单演示。这可能对某人有帮助。它在后台线程中下载图像。图像正在缓存在SD卡和内存中。缓存实现非常简单,仅适用于演示。我用inSampleSize解码图像以减少内存消耗。我也试图正确处理回收的意见。[26]




其它参考2


我推荐开源乐器通用图像加载器。它最初基于Fedor Vlasov的项目 LazyList ,并且从那时起已经大大改进。[27]



  • 多线程图像加载

  • 可以广泛调整ImageLoader的配置(线程执行器,下载器,解码器,内存和光盘缓存,显示图像选项等)

  • 在内存和/或设备的文件系统(或SD卡)上进行图像缓存的可能性

  • 倾听加载过程的可能性

  • 可以使用分开的选项自定义每个显示图像调用

  • 小工具支持

  • Android 2.0+支持



[28]

其它参考3


Multithreading For Performance,Gilles Debunne的教程。[29]


这是来自Android开发者博客。建议的代码使用:



  • AsyncTasks

  • 坚硬,有限的尺寸,FIFO cache

  • 一个柔软,轻松garbage collect - 缓存。

  • 下载时占位符 Drawable





其它参考4


更新:请注意,这个答案现在非常无效。垃圾收集器对SoftReference和WeakReference采取积极行动,因此此代码不适用于新的应用程序。(相反,请尝试在其他答案中建议使用Universal Image Loader等库。)[30]


感谢James的代码,以及Bao-Long建议使用SoftReference。我在James代码上实现了SoftReference更改。不幸的是,SoftReferences导致我的图像被垃圾收集得太快。在我的情况下没有SoftReference的东西很好,因为我的列表大小有限而且我的图像很小。


有一年前关于google群组的SoftReferences的讨论:链接到线程。作为过早垃圾收集的解决方案,他们建议使用dalvik.system.VMRuntime.setMinimumHeapSize手动设置VM堆大小的可能性。 ),这对我不是很有吸引力。[31]


public DrawableManager() {
    drawableMap = new HashMap<String, SoftReference<Drawable>>();
}

public Drawable fetchDrawable(String urlString) {
    SoftReference<Drawable> drawableRef = drawableMap.get(urlString);
    if (drawableRef != null) {
        Drawable drawable = drawableRef.get();
        if (drawable != null)
            return drawable;
        // Reference has expired so remove the key from drawableMap
        drawableMap.remove(urlString);
    }

    if (Constants.LOGGING) Log.d(this.getClass().getSimpleName(), "image url:" + urlString);
    try {
        InputStream is = fetch(urlString);
        Drawable drawable = Drawable.createFromStream(is, "src");
        drawableRef = new SoftReference<Drawable>(drawable);
        drawableMap.put(urlString, drawableRef);
        if (Constants.LOGGING) Log.d(this.getClass().getSimpleName(), "got a thumbnail drawable: " + drawable.getBounds() + ", "
                + drawable.getIntrinsicHeight() + "," + drawable.getIntrinsicWidth() + ", "
                + drawable.getMinimumHeight() + "," + drawable.getMinimumWidth());
        return drawableRef.get();
    } catch (MalformedURLException e) {
        if (Constants.LOGGING) Log.e(this.getClass().getSimpleName(), "fetchDrawable failed", e);
        return null;
    } catch (IOException e) {
        if (Constants.LOGGING) Log.e(this.getClass().getSimpleName(), "fetchDrawable failed", e);
        return null;
    }
}

public void fetchDrawableOnThread(final String urlString, final ImageView imageView) {
    SoftReference<Drawable> drawableRef = drawableMap.get(urlString);
    if (drawableRef != null) {
        Drawable drawable = drawableRef.get();
        if (drawable != null) {
            imageView.setImageDrawable(drawableRef.get());
            return;
        }
        // Reference has expired so remove the key from drawableMap
        drawableMap.remove(urlString);
    }

    final Handler handler = new Handler() {
        @Override
        public void handleMessage(Message message) {
            imageView.setImageDrawable((Drawable) message.obj);
        }
    };

    Thread thread = new Thread() {
        @Override
        public void run() {
            //TODO : set imageView to a "pending" image
            Drawable drawable = fetchDrawable(urlString);
            Message message = handler.obtainMessage(1, drawable);
            handler.sendMessage(message);
        }
    };
    thread.start();
}

其它参考5


毕加索


使用杰克沃顿的毕加索图书馆。
(一个完美的ImageLoading Library构成ActionBarSherlock的开发者)


适用于Android的强大图像下载和缓存库。


图像为Android应用程序添加了急需的上下文和视觉风格。 Picasso允许在您的应用程序中轻松加载图像 - 通常只需一行代码!


Picasso.with(context).load("http://i.imgur.com/DvpvklR.png").into(imageView);


Android上图像加载的许多常见缺陷由Picasso自动处理:


在适配器中处理ImageView回收和下载取消。
复杂的图像转换,内存使用最少。
自动内存和磁盘缓存。


毕加索杰克沃顿图书馆[32]


滑翔


Glide是一个快速高效的Android开源媒体管理框架,它将媒体解码,内存和磁盘缓存以及资源池包装成一个简单易用的界面。


Glide支持提取,解码和显示视频静止图像,图像和动画GIF。 Glide包含一个灵活的api,允许开发人员插入几乎任何网络堆栈。默认情况下,Glide使用基于HttpUrlConnection的自定义堆栈,但也包括插入Google的Volley项目或Square的OkHttp库的实用程序库。


Glide.with(this).load("http://goo.gl/h8qOq7").into(imageView);


Glide的主要重点是尽可能平滑和快速地滚动任何类型的图像列表,但Glide对于几乎任何需要获取,调整大小和显示远程图像的情况也很有效。


Glide Image Loading Library [33]


Facebook的壁画


Fresco是一个功能强大的系统,用于在Android应用程序中显示图像。


Fresco负责图像加载和显示,因此您不必这样做。它将从网络,本地存储或本地资源加载图像,并在图像到达之前显示占位符。它具有两级缓存;一个在内存中,另一个在内部存储中。


Fresco Github [34]


在Android 4.x及更低版本中,Fresco将图像放在Android内存的特殊区域。这可以让您的应用程序运行得更快 - 并且可以更少地遭遇可怕的OutOfMemoryError。


壁画文献[35]

其它参考6


高性能加载器 - 在检查了这里建议的方法之后,
我用Ben的解决方案做了一些改变 - [36]



  1. 我意识到使用drawables比使用位图更快,所以我使用drawables代替

  2. 使用SoftReference非常棒,但它会使缓存的图像被删除太频繁,因此我添加了一个包含图像引用的链接列表,防止图像被删除,直到达到预定义的大小

  3. 要打开InputStream,我使用java.net.URLConnection,它允许我使用Web缓存(您需要先设置响应缓存,但这是另一个故事)



我的代码:


import java.util.Map; 
import java.util.HashMap; 
import java.util.LinkedList; 
import java.util.Collections; 
import java.util.WeakHashMap; 
import java.lang.ref.SoftReference; 
import java.util.concurrent.Executors; 
import java.util.concurrent.ExecutorService; 
import android.graphics.drawable.Drawable;
import android.widget.ImageView;
import android.os.Handler;
import android.os.Message;
import java.io.InputStream;
import java.net.MalformedURLException; 
import java.io.IOException; 
import java.net.URL;
import java.net.URLConnection;

public class DrawableBackgroundDownloader {    

private final Map<String, SoftReference<Drawable>> mCache = new HashMap<String, SoftReference<Drawable>>();   
private final LinkedList <Drawable> mChacheController = new LinkedList <Drawable> ();
private ExecutorService mThreadPool;  
private final Map<ImageView, String> mImageViews = Collections.synchronizedMap(new WeakHashMap<ImageView, String>());  

public static int MAX_CACHE_SIZE = 80; 
public int THREAD_POOL_SIZE = 3;

/**
 * Constructor
 */
public DrawableBackgroundDownloader() {  
    mThreadPool = Executors.newFixedThreadPool(THREAD_POOL_SIZE);  
}  


/**
 * Clears all instance data and stops running threads
 */
public void Reset() {
    ExecutorService oldThreadPool = mThreadPool;
    mThreadPool = Executors.newFixedThreadPool(THREAD_POOL_SIZE);
    oldThreadPool.shutdownNow();

    mChacheController.clear();
    mCache.clear();
    mImageViews.clear();
}  

public void loadDrawable(final String url, final ImageView imageView,Drawable placeholder) {  
    mImageViews.put(imageView, url);  
    Drawable drawable = getDrawableFromCache(url);  

    // check in UI thread, so no concurrency issues  
    if (drawable != null) {  
        //Log.d(null, "Item loaded from mCache: " + url);  
        imageView.setImageDrawable(drawable);  
    } else {  
        imageView.setImageDrawable(placeholder);  
        queueJob(url, imageView, placeholder);  
    }  
} 


private Drawable getDrawableFromCache(String url) {  
    if (mCache.containsKey(url)) {  
        return mCache.get(url).get();  
    }  

    return null;  
}

private synchronized void putDrawableInCache(String url,Drawable drawable) {  
    int chacheControllerSize = mChacheController.size();
    if (chacheControllerSize > MAX_CACHE_SIZE) 
        mChacheController.subList(0, MAX_CACHE_SIZE/2).clear();

    mChacheController.addLast(drawable);
    mCache.put(url, new SoftReference<Drawable>(drawable));

}  

private void queueJob(final String url, final ImageView imageView,final Drawable placeholder) {  
    /* Create handler in UI thread. */  
    final Handler handler = new Handler() {  
        @Override  
        public void handleMessage(Message msg) {  
            String tag = mImageViews.get(imageView);  
            if (tag != null && tag.equals(url)) {
                if (imageView.isShown())
                    if (msg.obj != null) {
                        imageView.setImageDrawable((Drawable) msg.obj);  
                    } else {  
                        imageView.setImageDrawable(placeholder);  
                        //Log.d(null, "fail " + url);  
                    } 
            }  
        }  
    };  

    mThreadPool.submit(new Runnable() {  
        @Override  
        public void run() {  
            final Drawable bmp = downloadDrawable(url);
            // if the view is not visible anymore, the image will be ready for next time in cache
            if (imageView.isShown())
            {
                Message message = Message.obtain();  
                message.obj = bmp;
                //Log.d(null, "Item downloaded: " + url);  

                handler.sendMessage(message);
            }
        }  
    });  
}  



private Drawable downloadDrawable(String url) {  
    try {  
        InputStream is = getInputStream(url);

        Drawable drawable = Drawable.createFromStream(is, url);
        putDrawableInCache(url,drawable);  
        return drawable;  

    } catch (MalformedURLException e) {  
        e.printStackTrace();  
    } catch (IOException e) {  
        e.printStackTrace();  
    }  

    return null;  
}  


private InputStream getInputStream(String urlString) throws MalformedURLException, IOException {
    URL url = new URL(urlString);
    URLConnection connection;
    connection = url.openConnection();
    connection.setUseCaches(true); 
    connection.connect();
    InputStream response = connection.getInputStream();

    return response;
}
}

其它参考7


我已经关注了这个Android培训,我认为它在下载图像方面表现非常出色而不会阻止主UI。它还处理缓存和处理滚动许多图像:有效地加载大位图[37]




其它参考8


1. Picasso 允许在您的应用中加载无忧图像 - 通常只需一行代码![38]


使用Gradle:


implementation 'com.squareup.picasso:picasso:2.71828'


只需一行代码!


Picasso.get().load("http://i.imgur.com/DvpvklR.png").into(imageView);


2。 Glide 适用于Android的图片加载和缓存库专注于平滑滚动[39]


使用Gradle:


repositories {
  mavenCentral() 
  google()
}

dependencies {
   implementation 'com.github.bumptech.glide:glide:4.7.1'
   annotationProcessor 'com.github.bumptech.glide:compiler:4.7.1'
}


//对于简单的视图:


  Glide.with(this).load("http://i.imgur.com/DvpvklR.png").into(imageView);


3。 fresco 是一款功能强大的系统,可在Android中显示图片
   applications.Fresco负责图像加载和显示,所以你没有
  到。[40]


Fresco入门 [41]

其它参考9


我已经编写了一个教程,解释了如何在listview中对图像进行延迟加载。我详细介绍了回收和并发问题。我还使用固定的线程池来防止产生大量线程。


在Listview教程[42]中延迟加载图像

其它参考10


我这样做的方法是启动一个线程来在后台下载图像,并为每个列表项提供一个回调。当图像下载完成后,它会调用回调来更新列表项的视图。


但是,当您回收视图时,此方法不能很好地工作。

其它参考11


我只想添加一个更好的例子, XML Adapters 。由于它被谷歌使用,我也使用相同的逻辑来避免OutOfMemory错误。[43]


基本上这个ImageDownloader是你的答案(因为它涵盖了你的大多数要求)。有些你也可以实现。[44]

其它参考12


我一直在使用新的Android Volley Library com.android.volley.toolbox.NetworkImageView中的NetworkImageView,它看起来效果很好。显然,这与Google Play和其他新的Google应用程序中使用的视图相同。绝对值得一试。[45]



  • Google I/O 2013排球图片缓存教程[46]

  • 开发者Google事件[47]


其它参考13


这是Android上的常见问题,许多人已经通过多种方式解决了这个问题。在我看来,我见过的最好的解决方案是相对较新的名为Picasso的图书馆。以下是重点:[48]



  • 开源,但以ActionBarSherlock成名Jake Wharton为首。

  • 使用一行代码
  • 从网络或应用资源异步加载图像
  • 自动ListView检测

  • 自动磁盘和内存缓存

  • 可以进行自定义转换

  • 许多可配置的选项

  • 超级简单的API

  • 经常更新


其它参考14


我认为这个问题在Android开发人员中非常受欢迎,并且有很多这样的图书馆声称可以解决这个问题,但其中只有少数似乎是标记。 AQuery就是这样一个库,但它在各方面都比大多数都要好,值得一试。[49] [50]

其它参考15


那么,来自互联网的图像加载时间有很多解决方案。您也可以使用Android-Query库。它将为您提供所有必需的Activity。确保您要执行的操作并阅读库Wiki页面。并解决图像加载限制。[51]


这是我的代码:


@Override
public View getView(int position, View convertView, ViewGroup parent) {
    View v = convertView;
    if (v == null) {
        LayoutInflater vi = (LayoutInflater)getSystemService(Context.LAYOUT_INFLATER_SERVICE);
        v = vi.inflate(R.layout.row, null);
    }

    ImageView imageview = (ImageView) v.findViewById(R.id.icon);
    AQuery aq = new AQuery(convertView);

    String imageUrl = "http://www.vikispot.com/z/images/vikispot/android-w.png";

    aq.id(imageview).progress(this).image(imageUrl, true, true, 0, 0, new BitmapAjaxCallback() {
        @Override
        public void callback(String url, ImageView iv, Bitmap bm, AjaxStatus status) {
            iv.setImageBitmap(bm);
        }
    ));

    return v;
}


它应该解决你的延迟加载问题。

其它参考16


看看Shutterbug,Applidium的轻量级SDWebImage(iOS上的一个不错的库)到Android的端口。
它支持异步缓存,存储失败的URL,很好地处理并发,并包含有用的子类。[52]


拉动请求(和错误报告)也是受欢迎的!

其它参考17


你必须尝试这种通用装载机是最好的。
在懒惰加载完成许多RnD之后我正在使用它。


通用图像加载器[53]


功能



  • 多线程图像加载(异步或同步)

  • ImageLoader配置的广泛定制(线程执行器,下载器,解码器,内存和磁盘缓存,显示图像选项等)

  • 每个显示图像调用的许多自定义选项(存根图像,缓存切换,解码选项,位图处理和显示等)

  • 内存和/或磁盘(设备的文件系统或SD卡)上的图像缓存

  • 听取加载过程(包括下载进度)



Android 2.0+支持




其它参考18


DroidParts有ImageFetcher,需要零配置才能开始。[54] [55]



  • 使用磁盘&内存中最近最少使用(LRU)缓存。

  • 高效解码图像。

  • 支持在后台线程中修改位图。

  • 简单的交叉淡化。

  • 图片加载进度回调。



克隆DroidPartsGram为例:[56] [57]




其它参考19


Novoda还有一个很棒的懒人图像加载库,许多应用程序如Songkick,Podio,SecretDJ和ImageSearch使用他们的库。[58]


他们的图书馆在Github上托管,他们也有一个非常活跃的问题跟踪器。他们的项目似乎也非常活跃,在撰写本回复时有超过300次提交。[59] [60]

其它参考20


对于一个犹豫不决的人来说,只是一个快速的提示,关于用于延迟加载图像的库:


有四种基本方式。



  1. DIY =>不是最好的解决方案,但对于一些图像,如果你想没有使用其他库的麻烦

  2. Volley的懒人加载库=>来自android的人。这很好,但是文档记录很少,因此是一个问题。

  3. Picasso:一个简单的解决方案,只需工作,您甚至可以指定您想要引入的确切图像大小。它使用起来非常简单,但对于必须处理大量数据的应用程序可能不是非常高效图片。

  4. UIL:延迟加载图片的最佳方式。您可以缓存图像(当然需要权限),初始化加载程序一次,然后完成工作。到目前为止我见过的最成熟的异步图像加载库。


其它参考21


检查我的LazyList分支。基本上,我通过延迟ImageView的调用来改进LazyList并创建两个方法:[61]



  1. 当您需要输入类似正在加载图片...的文件时

  2. 当您需要显示下载的图像时。



我还通过在此对象中实现单例来改进ImageLoader。[62]

其它参考22


以上所有代码都有自己的价值,但根据我的个人经验,只需尝试一下毕加索。


Picasso 是一个专门用于此目的的库,实际上它将自动管理缓存和所有其他网络操作。您将不得不在项目中添加库,只需编写一行代码来加载图像来自远程URL。


请访问:http://code.tutsplus.com/tutorials/android-sdk-working-with-picasso--cms-22149 [63]

其它参考23


我可以推荐一种不同于魅力的方式:Android Query。


您可以从这里[64] [65]下载该JAR文件


AQuery androidAQuery = new AQuery(this);


举个例子:


androidAQuery.id(YOUR IMAGEVIEW).image(YOUR IMAGE TO LOAD, true, true, getDeviceWidth(), ANY DEFAULT IMAGE YOU WANT TO SHOW);


它非常快速和准确,使用它你可以找到更多的功能,如加载动画,获取位图(如果需要)等。

其它参考24


试试Aquery吧。它有非常简单的方法来异步加载和缓存图像。[66]

其它参考25


URLImageViewHelper是一个很棒的库,可以帮助您实现这一目标。 [67]

其它参考26


使用滑动库。它对我有用,也适用于你的代码。它既适用于图像,也适用于GIF。


ImageView imageView = (ImageView) findViewById(R.id.test_image); 
    GlideDrawableImageViewTarget imagePreview = new GlideDrawableImageViewTarget(imageView);
    Glide
            .with(this)
            .load(url)
            .listener(new RequestListener<String, GlideDrawable>() {
                @Override
                public boolean onException(Exception e, String model, Target<GlideDrawable> target, boolean isFirstResource) {                       
                    return false;
                }

                @Override
                public boolean onResourceReady(GlideDrawable resource, String model, Target<GlideDrawable> target, boolean isFromMemoryCache, boolean isFirstResource) {
                    return false;
                }
            })
            .into(imagePreview);
}

其它参考27


public class ImageDownloader {

Map<String, Bitmap> imageCache;

public ImageDownloader() {
    imageCache = new HashMap<String, Bitmap>();

}

// download function
public void download(String url, ImageView imageView) {
    if (cancelPotentialDownload(url, imageView)) {

        // Caching code right here
        String filename = String.valueOf(url.hashCode());
        File f = new File(getCacheDirectory(imageView.getContext()),
                filename);

        // Is the bitmap in our memory cache?
        Bitmap bitmap = null;

        bitmap = (Bitmap) imageCache.get(f.getPath());

        if (bitmap == null) {

            bitmap = BitmapFactory.decodeFile(f.getPath());

            if (bitmap != null) {
                imageCache.put(f.getPath(), bitmap);
            }

        }
        // No? download it
        if (bitmap == null) {
            try {
                BitmapDownloaderTask task = new BitmapDownloaderTask(
                        imageView);
                DownloadedDrawable downloadedDrawable = new DownloadedDrawable(
                        task);
                imageView.setImageDrawable(downloadedDrawable);
                task.execute(url);
            } catch (Exception e) {
                Log.e("Error==>", e.toString());
            }

        } else {
            // Yes? set the image
            imageView.setImageBitmap(bitmap);
        }
    }
}

// cancel a download (internal only)
private static boolean cancelPotentialDownload(String url,
        ImageView imageView) {
    BitmapDownloaderTask bitmapDownloaderTask = getBitmapDownloaderTask(imageView);

    if (bitmapDownloaderTask != null) {
        String bitmapUrl = bitmapDownloaderTask.url;
        if ((bitmapUrl == null) || (!bitmapUrl.equals(url))) {
            bitmapDownloaderTask.cancel(true);
        } else {
            // The same URL is already being downloaded.
            return false;
        }
    }
    return true;
}

// gets an existing download if one exists for the imageview
private static BitmapDownloaderTask getBitmapDownloaderTask(
        ImageView imageView) {
    if (imageView != null) {
        Drawable drawable = imageView.getDrawable();
        if (drawable instanceof DownloadedDrawable) {
            DownloadedDrawable downloadedDrawable = (DownloadedDrawable) drawable;
            return downloadedDrawable.getBitmapDownloaderTask();
        }
    }
    return null;
}

// our caching functions
// Find the dir to save cached images
private static File getCacheDirectory(Context context) {
    String sdState = android.os.Environment.getExternalStorageState();
    File cacheDir;

    if (sdState.equals(android.os.Environment.MEDIA_MOUNTED)) {
        File sdDir = android.os.Environment.getExternalStorageDirectory();

        // TODO : Change your diretcory here
        cacheDir = new File(sdDir, "data/ToDo/images");
    } else
        cacheDir = context.getCacheDir();

    if (!cacheDir.exists())
        cacheDir.mkdirs();
    return cacheDir;
}

private void writeFile(Bitmap bmp, File f) {
    FileOutputStream out = null;

    try {
        out = new FileOutputStream(f);
        bmp.compress(Bitmap.CompressFormat.PNG, 80, out);
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        try {
            if (out != null)
                out.close();
        } catch (Exception ex) {
        }
    }
}

// download asynctask
public class BitmapDownloaderTask extends AsyncTask<String, Void, Bitmap> {
    private String url;
    private final WeakReference<ImageView> imageViewReference;

    public BitmapDownloaderTask(ImageView imageView) {
        imageViewReference = new WeakReference<ImageView>(imageView);
    }

    @Override
    // Actual download method, run in the task thread
    protected Bitmap doInBackground(String... params) {
        // params comes from the execute() call: params[0] is the url.
        url = (String) params[0];
        return downloadBitmap(params[0]);
    }

    @Override
    // Once the image is downloaded, associates it to the imageView
    protected void onPostExecute(Bitmap bitmap) {
        if (isCancelled()) {
            bitmap = null;
        }

        if (imageViewReference != null) {
            ImageView imageView = imageViewReference.get();
            BitmapDownloaderTask bitmapDownloaderTask = getBitmapDownloaderTask(imageView);
            // Change bitmap only if this process is still associated with
            // it
            if (this == bitmapDownloaderTask) {
                imageView.setImageBitmap(bitmap);

                // cache the image

                String filename = String.valueOf(url.hashCode());
                File f = new File(
                        getCacheDirectory(imageView.getContext()), filename);

                imageCache.put(f.getPath(), bitmap);

                writeFile(bitmap, f);
            }
        }
    }

}

static class DownloadedDrawable extends ColorDrawable {
    private final WeakReference<BitmapDownloaderTask> bitmapDownloaderTaskReference;

    public DownloadedDrawable(BitmapDownloaderTask bitmapDownloaderTask) {
        super(Color.WHITE);
        bitmapDownloaderTaskReference = new WeakReference<BitmapDownloaderTask>(
                bitmapDownloaderTask);
    }

    public BitmapDownloaderTask getBitmapDownloaderTask() {
        return bitmapDownloaderTaskReference.get();
    }
}

// the actual download code
static Bitmap downloadBitmap(String url) {
    HttpParams params = new BasicHttpParams();
    params.setParameter(CoreProtocolPNames.PROTOCOL_VERSION,
            HttpVersion.HTTP_1_1);
    HttpClient client = new DefaultHttpClient(params);
    final HttpGet getRequest = new HttpGet(url);

    try {
        HttpResponse response = client.execute(getRequest);
        final int statusCode = response.getStatusLine().getStatusCode();
        if (statusCode != HttpStatus.SC_OK) {
            Log.w("ImageDownloader", "Error " + statusCode
                    + " while retrieving bitmap from " + url);
            return null;
        }

        final HttpEntity entity = response.getEntity();
        if (entity != null) {
            InputStream inputStream = null;
            try {
                inputStream = entity.getContent();
                final Bitmap bitmap = BitmapFactory
                        .decodeStream(inputStream);
                return bitmap;
            } finally {
                if (inputStream != null) {
                    inputStream.close();
                }
                entity.consumeContent();
            }
        }
    } catch (Exception e) {
        // Could provide a more explicit error message for IOException or
        // IllegalStateException
        getRequest.abort();
        Log.w("ImageDownloader", "Error while retrieving bitmap from "
                + url + e.toString());
    } finally {
        if (client != null) {
            // client.close();
        }
    }
    return null;
 }
}

其它参考28


我有这个问题并实现了lruCache。我相信您需要API 12及更高版本或使用兼容性v4库。 lurCache是​​快速内存,但它也有预算,所以如果你担心你可以使用磁盘缓存......它就在缓存位图中描述。[68]


我现在将提供我的实现,这是我从这样的任何地方调用的单例:[69]


//Where the first is a string and the other is a imageview to load.

DownloadImageTask.getInstance().loadBitmap(avatarURL, iv_avatar);


这是缓存的理想代码,然后在检索Web图像时在适配器的getView中调用上面的代码:


public class DownloadImageTask {

    private LruCache<String, Bitmap> mMemoryCache;

    /* Create a singleton class to call this from multiple classes */

    private static DownloadImageTask instance = null;

    public static DownloadImageTask getInstance() {
        if (instance == null) {
            instance = new DownloadImageTask();
        }
        return instance;
    }

    //Lock the constructor from public instances
    private DownloadImageTask() {

        // Get max available VM memory, exceeding this amount will throw an
        // OutOfMemory exception. Stored in kilobytes as LruCache takes an
        // int in its constructor.
        final int maxMemory = (int) (Runtime.getRuntime().maxMemory() / 1024);

        // Use 1/8th of the available memory for this memory cache.
        final int cacheSize = maxMemory / 8;

        mMemoryCache = new LruCache<String, Bitmap>(cacheSize) {
            @Override
            protected int sizeOf(String key, Bitmap bitmap) {
                // The cache size will be measured in kilobytes rather than
                // number of items.
                return bitmap.getByteCount() / 1024;
            }
        };
    }

    public void loadBitmap(String avatarURL, ImageView imageView) {
        final String imageKey = String.valueOf(avatarURL);

        final Bitmap bitmap = getBitmapFromMemCache(imageKey);
        if (bitmap != null) {
            imageView.setImageBitmap(bitmap);
        } else {
            imageView.setImageResource(R.drawable.ic_launcher);

            new DownloadImageTaskViaWeb(imageView).execute(avatarURL);
        }
    }

    private void addBitmapToMemoryCache(String key, Bitmap bitmap) {
        if (getBitmapFromMemCache(key) == null) {
            mMemoryCache.put(key, bitmap);
        }
    }

    private Bitmap getBitmapFromMemCache(String key) {
        return mMemoryCache.get(key);
    }

    /* A background process that opens a http stream and decodes a web image. */

    class DownloadImageTaskViaWeb extends AsyncTask<String, Void, Bitmap> {
        ImageView bmImage;

        public DownloadImageTaskViaWeb(ImageView bmImage) {
            this.bmImage = bmImage;
        }

        protected Bitmap doInBackground(String... urls) {

            String urldisplay = urls[0];
            Bitmap mIcon = null;
            try {
                InputStream in = new java.net.URL(urldisplay).openStream();
                mIcon = BitmapFactory.decodeStream(in);

            } 
            catch (Exception e) {
                Log.e("Error", e.getMessage());
                e.printStackTrace();
            }

            addBitmapToMemoryCache(String.valueOf(urldisplay), mIcon);

            return mIcon;
        }

        /* After decoding we update the view on the main UI. */
        protected void onPostExecute(Bitmap result) {
            bmImage.setImageBitmap(result);
        }
    }
}

其它参考29


您可以尝试使用 Aquery Android 库进行延迟加载图片和listview ...以下代码可以帮助您.....从这里下载库。[70]]]


AQuery aq = new AQuery(mContext);
aq.id(R.id.image1).image("http://data.whicdn.com/images/63995806/original.jpg");