首页 > 代码库 > 使用Lrucache，图片滑动时使用默认图片，停止时加载

使用Lrucache，图片滑动时使用默认图片，停止时加载

2024-08-15 11:14:35   222人阅读

注意：LruCache是有版本限制的，低版本的sdk需要在libs文件夹添加相应的support-4v文件。
本文改造的大部分是参考http://www.iteye.com/topic/1118828，感谢。
不废话直接上工程代码，内有关键注释，项目就不上传了，自己对照着上面网址改呗。


首先是Application文件，负责创建图片存储文件夹：

public class MyApp extends Application{    @Override    public void onCreate() {        super.onCreate();        File f = new File(Environment.getExternalStorageDirectory()+"/TestSyncListView/pic/");        if (!f.exists()) {            f.mkdirs();        }    }}


图像读取工具类：

public class SyncImageLoaderUtil {
    private Object lock = new Object(); 
       
    private boolean mAllowLoad = true; 
   
    private boolean firstLoad = true; 
   
    private int mStartLoadLimit = 0; 
   
    private int mStopLoadLimit = 0; 
   
    final Handler handler = new Handler(); 
   
//    private HashMap<String, SoftReference<Drawable>> imageCache = new HashMap<String, SoftReference<Drawable>>(); 
   
    private LruCache<String,Bitmap> mMemoryCache;
     
    RunInOtherThread runInOutherThread; 
   
    public SyncImageLoaderUtil(Context context) { 
        super(); 
         
        int memClass = ((ActivityManager)context.getSystemService(Context.ACTIVITY_SERVICE)).getMemoryClass();
        int cacheSize = 1024 * 1024 *memClass / 8;
        mMemoryCache = new LruCache<String, Bitmap>(cacheSize){
            @Override
            protected int sizeOf(String key, Bitmap value) {
                // TODO Auto-generated method stub
                return value.getRowBytes();
            }
        };
         
        runInOutherThread = new RunInOtherThread(); 
        runInOutherThread.start(); 
    } 
   
    public interface OnImageLoadListener { 
        public void onImageLoad(Integer t, Drawable drawable); 
   
        public void onError(Integer t); 
    } 
   
    public void setLoadLimit(int startLoadLimit, int stopLoadLimit) { 
        if (startLoadLimit > stopLoadLimit) { 
//          LogUtil.i("test", startLoadLimit+"--错误---"+stopLoadLimit);
            return; 
        } 
        mStartLoadLimit = startLoadLimit; 
        mStopLoadLimit = stopLoadLimit; 
    } 
   
    public void restore() { 
        mAllowLoad = true; 
        firstLoad = true; 
    } 
   
    public void lock() { 
        mAllowLoad = false; 
        firstLoad = false; 
    } 
   
    public void unlock() { 
        mAllowLoad = true; 
        synchronized (lock) { 
            lock.notifyAll(); 
        } 
    } 
   
    public void loadImage(Integer t, String imageUrl, 
            OnImageLoadListener listener) { 
        final OnImageLoadListener mListener = listener; 
        final String mImageUrl = imageUrl; 
        final Integer mt = t; 
           
        runInOutherThread.getHandler().post(new Runnable() { 
   
            @Override 
            public void run() { 
                if (!mAllowLoad) { 
                    synchronized (lock) { 
                        try { 
                            lock.wait(); 
                        } catch (InterruptedException e) { 
                            // TODO Auto-generated catch block 
                            e.printStackTrace(); 
                        } 
                    } 
                } 
                   
                if (mAllowLoad && firstLoad) { 
                    loadImage(mImageUrl, mt, mListener); 
                } 
   
//                LogUtil.e("test", "原始开始："+mStartLoadLimit+"原始当前位置："+mt+"原始结束："+mStopLoadLimit);
                if (mAllowLoad && mt <= mStopLoadLimit && mt >= mStartLoadLimit) { 
//                  LogUtil.e("test", "开始："+mStartLoadLimit+"当前位置："+mt+"结束："+mStopLoadLimit);
                    loadImage(mImageUrl, mt, mListener);
                } 
            } 
   
        }); 
    } 
       
    private void loadImage(final String mImageUrl, final Integer mt, 
            final OnImageLoadListener mListener) { 
   
        if (mImageUrl!=null && mMemoryCache.get(mImageUrl)!=null) { 
//            SoftReference<Drawable> softReference = imageCache.get(mImageUrl); 
            final Drawable d = new BitmapDrawable(mMemoryCache.get(mImageUrl)); 
//            LogUtil.d("ppp", "drawable:"+d);
            if (d != null) { 
                handler.post(new Runnable() { 
                    @Override 
                    public void run() { 
                        if (mAllowLoad) { 
                            mListener.onImageLoad(mt, d); 
                        } 
                    } 
                }); 
                return; 
            } 
        } 
        try { 
            final Drawable d = loadImageFromUrl(mImageUrl); 
            if (d != null) { 
                mMemoryCache.put(mImageUrl, ((BitmapDrawable)d).getBitmap());
            } 
            handler.post(new Runnable() { 
                @Override 
                public void run() { 
                    if (mAllowLoad) { 
                        mListener.onImageLoad(mt, d); 
                    } 
                } 
            }); 
        } catch (IOException e) { 
            handler.post(new Runnable() { 
                @Override 
                public void run() { 
                    mListener.onError(mt); 
                } 
            }); 
            e.printStackTrace(); 
        } 
    } 
   
    public static Drawable loadImageFromUrl(String url) throws IOException { 
        //DebugUtil.debug(url); 
        if (Environment.getExternalStorageState().equals( 
                Environment.MEDIA_MOUNTED)) { 
            File f = new File(Environment.getExternalStorageDirectory() 
                    + "/Weiyu/pic/" + MD5Util.getMD5(url.getBytes())); 
            if (f.exists()) { 
                FileInputStream fis = new FileInputStream(f); 
                Drawable d = Drawable.createFromStream(fis, "src"); 
                return d; 
            } 
            URL m = new URL(url); 
            InputStream i = (InputStream) m.getContent(); 
            DataInputStream in = new DataInputStream(i); 
            FileOutputStream out = new FileOutputStream(f); 
            byte[] buffer = new byte[1024]; 
            int byteread = 0; 
            while ((byteread = in.read(buffer)) != -1) { 
                out.write(buffer, 0, byteread); 
            } 
            
            in.close(); 
            out.close();
            return loadImageFromUrl(url); 
        } else { 
            URL m = new URL(url); 
            InputStream i = (InputStream) m.getContent(); 
            Drawable d = Drawable.createFromStream(i, "src"); 
            return d; 
        } 
   
    } 
}

　　
线程辅助类：

public class RunInOtherThread {
    private static final String LOG_TAG = "RunInOtherThread"; 
     
    private LooperThread localThread = new LooperThread(); 
       
    private boolean isRunning = true; 
   
    public Handler getHandler(){ 
        return localThread.getHandler(); 
    } 
       
    private class LooperThread extends Thread { 
        private Handler mHandler; 
   
        public void run() { 
            Looper.prepare(); 
            mHandler = new Handler() { 
                public void handleMessage(Message msg) { 
                    onReceiveMessage(msg.what); 
                } 
            }; 
            Looper.loop(); 
        } 
           
        Handler getHandler(){ 
            return mHandler; 
        } 
      
    } 
       
    public void start(){ 
        localThread.start(); 
    } 
       
    public void quit(){ 
        localThread.getHandler().getLooper().quit(); 
    } 
       
    public void sendMessage(int what){ 
        getHandler().sendEmptyMessage(what); 
    } 
       
    public Thread getThread(){ 
        return localThread; 
    } 
       
    public void onReceiveMessage(int what){};
}

　　
使用类：

// 实例化工具类
SyncImageLoaderUtil syncImageLoader = new SyncImageLoaderUtil(mContext);
 
syncImageLoader.loadImage(position, model.mPic, imageLoadListener);//应用接口：参数一是加载图片的位置；参数二是加载的ImageView；参数三是回调接口
 
// map保存的键是位置，值是listview对应位置的布局
HashMap map = new HashMap();
map.put(position, convertView);
 
SyncImageLoaderUtil.OnImageLoadListener imageLoadListener = new SyncImageLoaderUtil.OnImageLoadListener() {
 
        @Override
        public void onImageLoad(Integer t, Drawable drawable) {
            View view = (View) map.get(t);
            if (view != null) {
                ImageView iv = (ImageView) view.findViewById(R.id.image);
                iv.setBackgroundDrawable(drawable);
            }
        }
 
        @Override
        public void onError(Integer t) {
                        // 图片加载失败
                       // 取得listview对应的位置的行的内容布局
                    MusicModel model = (MusicModel) getItem(t);
            View view = mListView.findViewWithTag(model);
            if (view != null) {
                ImageView iv = (ImageView) view.findViewById(R.id.image);
                iv.setBackgroundResource(R.drawable.img_pic);
            }
        }
 
    };
 
 
// 实现类而且需要实现OnScrollListener接口
public void loadImage() {
                // 不要在这里使用listview的getFirstVisiblePosition方法，位置不准
        if (end >= getCount()) {
            end = getCount() - 1;
        }
        syncImageLoader.setLoadLimit(start, end);
        syncImageLoader.unlock();
    }
 
    @Override
    public void onScrollStateChanged(AbsListView view, int scrollState) {
        // TODO Auto-generated method stub
        if (lodingView) {
            switch (scrollState) {
            case AbsListView.OnScrollListener.SCROLL_STATE_FLING:
                syncImageLoader.lock();
                break;
            case AbsListView.OnScrollListener.SCROLL_STATE_IDLE:
 
                loadImage();
                break;
            case AbsListView.OnScrollListener.SCROLL_STATE_TOUCH_SCROLL:
                syncImageLoader.lock();
                break;
            default:
                break;
            }
        }
    }
 
    @Override
    public void onScroll(AbsListView view, int firstVisibleItem,
            int visibleItemCount, int totalItemCount) {
        // 在这里取得的位置较准确，不过也会出现特殊的奇疤机型是不行的
                // start与end是定义的变量
        start = firstVisibleItem;
        end = firstVisibleItem + visibleItemCount;
        if (firstVisibleItem != 0) {
                        // lodingView是控制变量，用来控制第一次进来视图加载读取图片
            lodingView = true;
        } else {
            lodingView = false;
            loadImage();
        }
    }


来自为知笔记(Wiz)


使用Lrucache，图片滑动时使用默认图片，停止时加载


联系
我们