優化ListView異步加載網絡圖片

 

寫這篇文章並非教你們怎麼樣用listview異步加載圖片，由於這樣的文章在網上已經有不少了，好比這位仁兄寫的就很好：

http://www.iteye.com/topic/685986

我也是由於看了這篇文章而受到了啓發。

先說說這篇文章的優勢把，開啓線程異步加載圖片，而後刷新UI顯示圖片，並且經過弱引用緩存網絡加載的圖片，節省了再次鏈接網絡的開銷。

這樣作無疑是很是可取的方法，可是加載圖片時仍然會感受到輕微的卡屏現象，特別是listview裏的item在進行快速滑動的時候。

我找了一下緣由，多是在listview快速滑動屏幕的時候劃過的item太多 並且每次調用getView方法後就會異步的在過去某個時間內用handler刷新一下UI，

若是在同一時間調用handler刷新UI次數多了就會形成這樣的卡屏現象。

 

後來又一想，其實咱們徹底沒有必要在listview正在滑動的時候去後臺加載圖片（無論這是圖片是在緩存裏仍是在網絡上），這樣無疑形成了很大的資源浪費。

咱們只須要在listview滑動中止以後再去加載listview裏面顯示的幾個item裏面的圖片就行了。

 

根據以上想法，我作了一些設計改造：

1.在adapter 的 getview方法裏面啓動加載圖片的thread，若是listview在滑動則wait

2.監聽listview滑動中止事件，得到listview顯示的item的最上面和最下面的序號，並喚醒全部加載圖片的thread，判斷加載圖片的序號是不是在範圍內，若是是則繼續加載，若是不是則結束thread

部分代碼以下：

@Override
public View getView(int position, View convertView, ViewGroup parent) {
	if(convertView == null){
		convertView = mInflater.inflate(R.layout.book_item_adapter, null);
	}
	BookModel model = mModels.get(position);
	convertView.setTag(position);
	ImageView iv = (ImageView) convertView.findViewById(R.id.sItemIcon);
	TextView sItemTitle =  (TextView) convertView.findViewById(R.id.sItemTitle);
	TextView sItemInfo =  (TextView) convertView.findViewById(R.id.sItemInfo);
	sItemTitle.setText(model.book_name);
	sItemInfo.setText(model.out_book_url);
	iv.setBackgroundResource(R.drawable.rc_item_bg);
	syncImageLoader.loadImage(position,model.out_book_pic,imageLoadListener);
	return  convertView;
}

SyncImageLoader.OnImageLoadListener imageLoadListener = new SyncImageLoader.OnImageLoadListener(){

	@Override
	public void onImageLoad(Integer t, Drawable drawable) {
		//BookModel model = (BookModel) getItem(t);
		View view = mListView.findViewWithTag(t);
		if(view != null){
			ImageView iv = (ImageView) view.findViewById(R.id.sItemIcon);
			iv.setBackgroundDrawable(drawable);
		}
	}
	@Override
	public void onError(Integer t) {
		BookModel model = (BookModel) getItem(t);
		View view = mListView.findViewWithTag(model);
		if(view != null){
			ImageView iv = (ImageView) view.findViewById(R.id.sItemIcon);
			iv.setBackgroundResource(R.drawable.rc_item_bg);
		}
	}
	
};

public void loadImage(){
	int start = mListView.getFirstVisiblePosition();
	int end =mListView.getLastVisiblePosition();
	if(end >= getCount()){
		end = getCount() -1;
	}
	syncImageLoader.setLoadLimit(start, end);
	syncImageLoader.unlock();
}

AbsListView.OnScrollListener onScrollListener = new AbsListView.OnScrollListener() {
	
	@Override
	public void onScrollStateChanged(AbsListView view, int scrollState) {
		switch (scrollState) {
			case AbsListView.OnScrollListener.SCROLL_STATE_FLING:
				DebugUtil.debug("SCROLL_STATE_FLING");
				syncImageLoader.lock();
				break;
			case AbsListView.OnScrollListener.SCROLL_STATE_IDLE:
				DebugUtil.debug("SCROLL_STATE_IDLE");
				loadImage();
				//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) {
		// TODO Auto-generated method stub
		
	}
};

 

Syncimageloader代碼

import java.io.DataInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.lang.ref.SoftReference;
import java.net.URL;
import java.util.HashMap;

import android.graphics.drawable.Drawable;
import android.os.Environment;
import android.os.Handler;

public class SyncImageLoader {

	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>>();   
	
	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){
			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;
		
		new Thread(new Runnable() {

			@Override
			public void run() {
				if(!mAllowLoad){
					DebugUtil.debug("prepare to load");
					synchronized (lock) {
						try {
							lock.wait();
						} catch (InterruptedException e) {
							// TODO Auto-generated catch block
							e.printStackTrace();
						}
					}
				}
				
				if(mAllowLoad && firstLoad){
					loadImage(mImageUrl, mt, mListener);
				}
				
				if(mAllowLoad && mt <= mStopLoadLimit && mt >= mStartLoadLimit){
					loadImage(mImageUrl, mt, mListener);
				}
			}

		}).start();
	}
	
	private void loadImage(final String mImageUrl,final Integer mt,final OnImageLoadListener mListener){
		
		if (imageCache.containsKey(mImageUrl)) {  
            SoftReference<Drawable> softReference = imageCache.get(mImageUrl);  
            final Drawable d = softReference.get();  
            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){
                imageCache.put(mImageUrl, new SoftReference<Drawable>(d));
			}
			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()+"/TestSyncListView/"+MD5.getMD5(url));
			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();
			Drawable d = Drawable.createFromStream(i, "src");
			return loadImageFromUrl(url);
		}else{
			URL m = new URL(url);
			InputStream i = (InputStream) m.getContent();
			Drawable d = Drawable.createFromStream(i, "src");
			return d;
		}
		
	}
}

 

爲了讓你們更好的理解，我添加了源代碼例子，還特意美化了一下UI

除了自己已有的弱引用緩存圖片，我還添加了本地SD卡緩存圖片（這兩種緩存方法各有好處，若是圖片常常變化建議內存緩存圖片，若是是不常常修改的圖片建議SD卡緩存）