异步加载图片（二）

前言：上篇《异步加载图片（一）》讲解了怎样实现异步加载图片，由于篇幅已经比较长就另开一篇讲解如何实现在用户滑动时停止加载图片，在停划时继续加载，这里我只贴出在上篇的基础上更改的部分，并加以讲解，对于完整的代码参照源码；

一、ImageAndTextListAdapter.java

先看完整代码，然后再讲更改的部分

[java] view plain copy

1. package cn.wangmeng.test;  
2.   
3. import java.util.ArrayList;  
4. import java.util.List;  
5. import cn.wangmeng.test.AsyncImageLoader.ImageCallback;  
6.   
7. import android.app.Activity;  
8. import android.graphics.drawable.Drawable;  
9. import android.util.Log;  
10. import android.view.LayoutInflater;  
11. import android.view.View;  
12. import android.view.ViewGroup;  
13. import android.widget.AbsListView;  
14. import android.widget.BaseAdapter;  
15. import android.widget.ImageView;  
16. import android.widget.ListView;  
17. import android.widget.TextView;  
18.   
19. public class ImageAndTextListAdapter extends BaseAdapter{  
20.   
21.         private LayoutInflater inflater;  
22.         private ListView listView;  
23.         private AsyncImageLoader asyncImageLoader;  
24.         private List<ImageAndText> dataArray=new ArrayList<ImageAndText>();  
25.   
26.         public ImageAndTextListAdapter(Activity activity, List<ImageAndText> imageAndTexts, ListView listView) {  
27.   
28.             this.listView = listView;  
29.             asyncImageLoader = new AsyncImageLoader();  
30.             inflater = activity.getLayoutInflater();  
31.             dataArray=imageAndTexts;  
32.               
33.             listView.setOnScrollListener(onScrollListener);  
34.         }  
35.           
36.         @Override  
37.         public int getCount() {  
38.             // TODO Auto-generated method stub  
39.             return dataArray.size();  
40.         }  
41.         @Override  
42.         public Object getItem(int position) {  
43.             // TODO Auto-generated method stub  
44.             if(position >= getCount()){  
45.                 return null;  
46.             }  
47.             return dataArray.get(position);  
48.         }  
49.         @Override  
50.         public long getItemId(int position) {  
51.             // TODO Auto-generated method stub  
52.             return position;  
53.         }  
54.         @Override  
55.         public View getView(int position, View convertView, ViewGroup parent) {  
56.             if (convertView == null) {  
57.                  convertView = inflater.inflate(R.layout.book_item_adapter, null);  
58.             }  
59.             convertView.setTag(position);  
60.               
61.             ImageAndText imageAndText = (ImageAndText) getItem(position);  
62.             String imageUrl = imageAndText.getImageUrl();  
63.               
64.             TextView textView =  (TextView) convertView.findViewById(R.id.sItemTitle);   
65.             // 将XML视图项与用户输入的URL和文本在绑定  
66.             textView.setText(imageAndText.getText());//加载TEXT  
67.             ImageView iv = (ImageView) convertView.findViewById(R.id.sItemIcon);  
68.             iv.setBackgroundResource(R.drawable.rc_item_bg);  
69.               
70.             // 加载IMG，并设定到ImageView中  
71.             asyncImageLoader.loadDrawable(position,imageUrl, new ImageCallback() {  
72.                 @Override  
73.                 public void onImageLoad(Integer pos, Drawable drawable) {  
74.                     View view = listView.findViewWithTag(pos);  
75.                     if(view != null){  
76.                         ImageView iv = (ImageView) view.findViewById(R.id.sItemIcon);  
77.                         iv.setBackgroundDrawable(drawable);  
78.                     }  
79.                 }  
80.                 //加载不成功的图片处理      
81.                 @Override  
82.                 public void onError(Integer pos) {  
83.                     View view = listView.findViewWithTag(pos);  
84.                     if(view != null){  
85.                         ImageView iv = (ImageView) view.findViewById(R.id.sItemIcon);  
86.                         iv.setBackgroundResource(R.drawable.rc_item_bg);  
87.                     }  
88.                 }  
89.                   
90.             });  
91.             return convertView;  
92.         }  
93.           
94.         public void loadImage(){  
95.             int start = listView.getFirstVisiblePosition();  
96.             int end =listView.getLastVisiblePosition();  
97.             if(end >= getCount()){  
98.                 end = getCount() -1;  
99.             }  
100.             asyncImageLoader.setLoadLimit(start, end);  
101.             asyncImageLoader.unlock();  
102.         }  
103.           
104.         AbsListView.OnScrollListener onScrollListener = new AbsListView.OnScrollListener() {  
105.               
106.             @Override  
107.             public void onScrollStateChanged(AbsListView view, int scrollState) {  
108.                 switch (scrollState) {  
109.                     case AbsListView.OnScrollListener.SCROLL_STATE_FLING:  
110.                         Log.v("msg", "SCROLL_STATE_FLING----lock");  
111.                         asyncImageLoader.lock();      
112.                         break;  
113.                     case AbsListView.OnScrollListener.SCROLL_STATE_IDLE:  
114.                         Log.v("msg", "SCROLL停了---加载");  
115.                         loadImage();      
116.                         //loadImage();  
117.                         break;  
118.                     case AbsListView.OnScrollListener.SCROLL_STATE_TOUCH_SCROLL:  
119.                         Log.d("msg", "SCROLL_STATE_TOUCH_SCROLL----lock");  
120.                         asyncImageLoader.lock();  
121.                         break;  
122.           
123.                     default:  
124.                         break;  
125.                 }  
126.                   
127.             }  
128.               
129.             @Override  
130.             public void onScroll(AbsListView view, int firstVisibleItem,  
131.                     int visibleItemCount, int totalItemCount) {  
132.                 // TODO Auto-generated method stub  
133.                   
134.             }  
135.         };  
136.   
137.   
138. }  

这里的代码较上篇增加了一个ListView的滑动监听器（AbsListView.OnScrollListener），然后在滑动的时候调用asyncImageLoader.lock();将其锁定，也就是利用互斥将线程阻塞；在用户停划的时候，调用loadImage();函数将线程唤醒；
这里有几个函数是AsyncImageLoader类里实现的函数：lock()----实现线程阻塞；unlock()------解除线程阻塞；setLoadLimit(start, end)-----首先找到列表中显示的ITEM的上限和下限；loadImage（）的功能就是先找到列表中在显示区域中的ITEM的上限POS和下限POS，然后只唤醒这几个线程，对于不在显示区域的线程仍然保持阻止；

二、AsyncImageLoader.java

先看完整代码：

[java] view plain copy

1. package cn.wangmeng.test;  
2.   
3. import java.io.IOException;  
4. import java.io.InputStream;  
5. import java.lang.ref.SoftReference;  
6. import java.net.URL;  
7. import java.util.HashMap;  
8.   
9. import android.graphics.drawable.Drawable;  
10. import android.os.Handler;  
11.   
12. public class AsyncImageLoader {  
13.     private Object lock = new Object();  
14.     private boolean mAllowLoad = true;  
15.     private boolean firstLoad = true;  
16.     private int mStartLoadLimit = 0;  
17.     private int mStopLoadLimit = 0;  
18.     final Handler handler = new Handler();  
19.   
20.     private HashMap<String, SoftReference<Drawable>> imageCache;  
21.   
22.     public AsyncImageLoader() {  
23.         imageCache = new HashMap<String, SoftReference<Drawable>>();  
24.     }  
25.   
26.     public void setLoadLimit(int startLoadLimit, int stopLoadLimit) {  
27.         if (startLoadLimit > stopLoadLimit) {  
28.             return;  
29.         }  
30.         mStartLoadLimit = startLoadLimit;  
31.         mStopLoadLimit = stopLoadLimit;  
32.     }  
33.   
34.     public void restore() {  
35.         mAllowLoad = true;  
36.         firstLoad = true;  
37.     }  
38.   
39.     public void lock() {  
40.         mAllowLoad = false;  
41.         firstLoad = false;  
42.     }  
43.   
44.     public void unlock() {  
45.         mAllowLoad = true;  
46.         synchronized (lock) {  
47.             lock.notifyAll();  
48.         }  
49.     }  
50.   
51.     public Drawable loadDrawable(final Integer pos, final String imageUrl,  
52.              final ImageCallback imageCallback) {  
53.         new Thread() {  
54.             @Override  
55.             public void run() {  
56.                 if (!mAllowLoad) {// 先阻塞线程  
57.                     synchronized (lock) {// 加锁  
58.                         try {  
59.                             lock.wait();  
60.                         } catch (InterruptedException e) {  
61.                             // TODO Auto-generated catch block  
62.                             e.printStackTrace();  
63.                         }  
64.                     }  
65.                 }  
66.                 // 如果是第一次加载XML就加载图片，对于是不是在显示范围内的加载控制放在VIEW中  
67.                 if (mAllowLoad && firstLoad) {  
68.                     LoadImg(pos, imageUrl, imageCallback);  
69.                 }  
70.                 // 对于在显示范围内的，对其加载IMG  
71.                 if (mAllowLoad && pos <= mStopLoadLimit  
72.                         && pos >= mStartLoadLimit) {  
73.                     LoadImg(pos, imageUrl, imageCallback);  
74.                 }  
75.   
76.             }  
77.         }.start();  
78.         return null;  
79.     }// loadDrawable---end  
80.   
81.     public void LoadImg(final Integer pos, final String imageUrl,  
82.             final ImageCallback imageCallback) {  
83.         // 首先判断是否在缓存中  
84.         // 但有个问题是：ImageCache可能会越来越大，以至用户内存用光，所以要用SoftReference（弱引用）来实现  
85.         if (imageCache.containsKey(imageUrl)) {  
86.             SoftReference<Drawable> softReference = imageCache.get(imageUrl);  
87.             final Drawable drawable = softReference.get();  
88.             if (drawable != null) {  
89.                 handler.post(new Runnable() {  
90.                     @Override  
91.                     public void run() {  
92.                         if (mAllowLoad) {  
93.                             imageCallback.onImageLoad(pos, drawable);  
94.                         }else {  
95.                             imageCallback.onError(pos);  
96.                         }  
97.                     }  
98.                 });  
99.                 return;  
100.             }  
101.         }  
102.         // 尝试从URL中加载  
103.         try {  
104.             final Drawable drawable = loadImageFromUrl(imageUrl);  
105.             if (drawable != null) {  
106.                 imageCache.put(imageUrl, new SoftReference<Drawable>(drawable));  
107.             }  
108.             handler.post(new Runnable() {  
109.                 @Override  
110.                 public void run() {  
111.                     if (mAllowLoad) {  
112.                         imageCallback.onImageLoad(pos, drawable);  
113.                     }  
114.                 }  
115.             });  
116.         } catch (IOException e) {  
117.             handler.post(new Runnable() {  
118.                 @Override  
119.                 public void run() {  
120.                     imageCallback.onError(pos);  
121.                 }  
122.             });  
123.             e.printStackTrace();  
124.         }  
125.   
126.     }  
127.   
128.     // 根据URL加载图片,如果出现错误throws IOException式的错误，以便在LoadImg中捕获，执行OnError（）函数  
129.     public static Drawable loadImageFromUrl(String url) throws IOException {  
130.         URL m;  
131.         InputStream i = null;  
132.         m = new URL(url);  
133.         i = (InputStream) m.getContent();  
134.         Drawable d = Drawable.createFromStream(i, "src");  
135.         return d;  
136.     }  
137.   
138.     // 回调函数  
139.     public interface ImageCallback {  
140.         // public void imageLoaded(Drawable imageDrawable,final ImageView  
141.         // imageView);  
142.         // public void onError(final ImageView imageView);  
143.         public void onImageLoad(Integer t, Drawable drawable);  
144.   
145.         public void onError(Integer t);  
146.     }  
147.   
148. }  

1、先看关键部分loadDrawable（）函数

[java] view plain copy

1. public Drawable loadDrawable(final Integer pos, final String imageUrl,  
2.          final ImageCallback imageCallback) {  
3.     new Thread() {  
4.         @Override  
5.         public void run() {  
6.             if (!mAllowLoad) {// 先阻塞线程  
7.                 synchronized (lock) {// 加锁  
8.                     try {  
9.                         lock.wait();  
10.                     } catch (InterruptedException e) {  
11.                         // TODO Auto-generated catch block  
12.                         e.printStackTrace();  
13.                     }  
14.                 }  
15.             }  
16.             // 如果是第一次加载XML就加载图片，对于是不是在显示范围内的加载控制放在VIEW中  
17.             if (mAllowLoad && firstLoad) {  
18.                 LoadImg(pos, imageUrl, imageCallback);  
19.             }  
20.             // 对于在显示范围内的，对其加载IMG  
21.             if (mAllowLoad && pos <= mStopLoadLimit  
22.                     && pos >= mStartLoadLimit) {  
23.                 LoadImg(pos, imageUrl, imageCallback);  
24.             }  
25.   
26.         }  
27.     }.start();  
28.     return null;  
29. }// loadDrawable---end  

这里较上回的不同点在于加了锁---synchronized (lock)；即如果用户不让加载的话，就利用synchronized (lock)和lock.wait()将线程阻塞，如果ITEM在加载范围内，就利用下面的LoadImg（）函数进行加载；
然后剩下的几个不同点就是加载ITEM范围限制的设定和加锁解锁的函数了；

[java] view plain copy

1. public void setLoadLimit(int startLoadLimit, int stopLoadLimit) {//显示上下限设定  
2.     if (startLoadLimit > stopLoadLimit) {  
3.         return;  
4.     }  
5.     mStartLoadLimit = startLoadLimit;  
6.     mStopLoadLimit = stopLoadLimit;  
7. }  
8.   
9. public void restore() {  
10.     mAllowLoad = true;  
11.     firstLoad = true;  
12. }  
13.   
14. public void lock() {//加锁  
15.     mAllowLoad = false;  
16.     firstLoad = false;  
17. }  
18.   
19. public void unlock() {//解锁  
20.     mAllowLoad = true;  
21.     synchronized (lock) {  
22.         lock.notifyAll();  
23.     }  
24. }  

这几个函数比较好理解，就不讲了；
这里就实现了所有的功能，这里主要参考了这两篇文章，在最后给出，感谢原作者的无私奉献！

《又优化了一个Android ListView异步加载图片》：http://www.iteye.com/topic/1118828

《又优化了一个Android ListView异步加载图片（续）》：http://www.iteye.com/topic/1127914

对于作者的续篇，为了解决这里的开的线程太多的问题，将所有的线程整合成一个线程，这样一尝试，加载速度明显慢了好多，其实可以利用信号量的原理，同时开几个线程或者线程池，本人也没那个能力将其改成线程池，本想利用AsyncTask来重新实现，因为AsyncTask使用的线程池，奈何技术不到位，实现不了……，只能再等高人去优化了。

源码地址：http://download.youkuaiyun.com/detail/harvic880925/6802321

请大家尊重原创者版权，转载请标明出处： http://blog.youkuaiyun.com/harvic880925/article/details/17782063   ，谢谢！！！！！！