Android异步加载网络图片

1. package com.wangge.uumao.http;  
2.   
3. import java.lang.ref.SoftReference;  
4. import java.util.ArrayList;  
5. import java.util.HashMap;  
6. import java.util.List;  
7. import java.util.Map;  
8.   
9. import android.graphics.Bitmap;  
10. import android.os.Handler;  
11. import android.os.Message;  
12. import android.util.Log;  
13. import android.widget.ImageView;  
14.   
15. import com.wangge.uumao.util.PicUtil;  
16.   
17. public class AsynImageLoader {  
18.     private static final String TAG = "AsynImageLoader";  
19.     // 缓存下载过的图片的Map  
20.     private Map<String, SoftReference<Bitmap>> caches;  
21.     // 任务队列  
22.     private List<Task> taskQueue;  
23.     private boolean isRunning = false;  
24.       
25.     public AsynImageLoader(){  
26.         // 初始化变量  
27.         caches = new HashMap<String, SoftReference<Bitmap>>();  
28.         taskQueue = new ArrayList<AsynImageLoader.Task>();  
29.         // 启动图片下载线程  
30.         isRunning = true;  
31.         new Thread(runnable).start();  
32.     }  
33.       
34.     /** 
35.      *  
36.      * @param imageView 需要延迟加载图片的对象 
37.      * @param url 图片的URL地址 
38.      * @param resId 图片加载过程中显示的图片资源 
39.      */  
40.     public void showImageAsyn(ImageView imageView, String url, int resId){  
41.         imageView.setTag(url);  
42.         Bitmap bitmap = loadImageAsyn(url, getImageCallback(imageView, resId));  
43.           
44.         if(bitmap == null){  
45.             imageView.setImageResource(resId);  
46.         }else{  
47.             imageView.setImageBitmap(bitmap);  
48.         }  
49.     }  
50.       
51.     public Bitmap loadImageAsyn(String path, ImageCallback callback){  
52.         // 判断缓存中是否已经存在该图片  
53.         if(caches.containsKey(path)){  
54.             // 取出软引用  
55.             SoftReference<Bitmap> rf = caches.get(path);  
56.             // 通过软引用，获取图片  
57.             Bitmap bitmap = rf.get();  
58.             // 如果该图片已经被释放，则将该path对应的键从Map中移除掉  
59.             if(bitmap == null){  
60.                 caches.remove(path);  
61.             }else{  
62.                 // 如果图片未被释放，直接返回该图片  
63.                 Log.i(TAG, "return image in cache" + path);  
64.                 return bitmap;  
65.             }  
66.         }else{  
67.             // 如果缓存中不常在该图片，则创建图片下载任务  
68.             Task task = new Task();  
69.             task.path = path;  
70.             task.callback = callback;  
71.             Log.i(TAG, "new Task ," + path);  
72.             if(!taskQueue.contains(task)){  
73.                 taskQueue.add(task);  
74.                 // 唤醒任务下载队列  
75.                 synchronized (runnable) {  
76.                     runnable.notify();  
77.                 }  
78.             }  
79.         }  
80.           
81.         // 缓存中没有图片则返回null  
82.         return null;  
83.     }  
84.       
85.     /** 
86.      *  
87.      * @param imageView  
88.      * @param resId 图片加载完成前显示的图片资源ID 
89.      * @return 
90.      */  
91.     private ImageCallback getImageCallback(final ImageView imageView, final int resId){  
92.         return new ImageCallback() {  
93.               
94.             @Override  
95.             public void loadImage(String path, Bitmap bitmap) {  
96.                 if(path.equals(imageView.getTag().toString())){  
97.                     imageView.setImageBitmap(bitmap);  
98.                 }else{  
99.                     imageView.setImageResource(resId);  
100.                 }  
101.             }  
102.         };  
103.     }  
104.       
105.     private Handler handler = new Handler(){  
106.   
107.         @Override  
108.         public void handleMessage(Message msg) {  
109.             // 子线程中返回的下载完成的任务  
110.             Task task = (Task)msg.obj;  
111.             // 调用callback对象的loadImage方法，并将图片路径和图片回传给adapter  
112.             task.callback.loadImage(task.path, task.bitmap);  
113.         }  
114.           
115.     };  
116.       
117.     private Runnable runnable = new Runnable() {  
118.           
119.         @Override  
120.         public void run() {  
121.             while(isRunning){  
122.                 // 当队列中还有未处理的任务时，执行下载任务  
123.                 while(taskQueue.size() > 0){  
124.                     // 获取第一个任务，并将之从任务队列中删除  
125.                     Task task = taskQueue.remove(0);  
126.                     // 将下载的图片添加到缓存  
127.                     task.bitmap = PicUtil.getbitmap(task.path);  
128.                     caches.put(task.path, new SoftReference<Bitmap>(task.bitmap));  
129.                     if(handler != null){  
130.                         // 创建消息对象，并将完成的任务添加到消息对象中  
131.                         Message msg = handler.obtainMessage();  
132.                         msg.obj = task;  
133.                         // 发送消息回主线程  
134.                         handler.sendMessage(msg);  
135.                     }  
136.                 }  
137.                   
138.                 //如果队列为空,则令线程等待  
139.                 synchronized (this) {  
140.                     try {  
141.                         this.wait();  
142.                     } catch (InterruptedException e) {  
143.                         e.printStackTrace();  
144.                     }  
145.                 }  
146.             }  
147.         }  
148.     };  
149.       
150.     //回调接口  
151.     public interface ImageCallback{  
152.         void loadImage(String path, Bitmap bitmap);  
153.     }  
154.       
155.     class Task{  
156.         // 下载任务的下载路径  
157.         String path;  
158.         // 下载的图片  
159.         Bitmap bitmap;  
160.         // 回调对象  
161.         ImageCallback callback;  
162.           
163.         @Override  
164.         public boolean equals(Object o) {  
165.             Task task = (Task)o;  
166.             return task.path.equals(path);  
167.         }  
168.     }  
169. }  

最后附上PicUtil类的代码，之前忘了贴这个类的代码，不好意识了~~

 FileUtil