Android异步加载图片并缓存到内存和SD卡上

Admin

1. * 异步加载图片
   
2. * 使用方法：
   
3. * private AsyncImageLoader asyImg = new AsyncImageLoader();
   
4. * asyImg.LoadImage(productItems.get(position).getPic(), (ImageView)view.findViewById(R.id.pic));
   
5. */
   
6. 
   
7. public class AsyncImageLoader {
   
8.         // 为了加快速度，在内存中开启缓存（主要应用于重复图片较多时，或者同一个图片要多次被访问，比如在ListView时来回滚动）
   
9.         public Map<String, SoftReference<Drawable>> imageCache = new HashMap<String, SoftReference<Drawable>>();
   
10.         private ExecutorService executorService = Executors.newFixedThreadPool(5); // 固定五个线程来执行任务
    
11.         private final Handler handler = new Handler();
    
12.         // SD卡上图片储存地址
    
13.         private final String path = Environment.getExternalStorageDirectory()
    
14.                         .getPath() + "/maiduo";
    
15. 
    
16.         /**
    
17.          *
    
18.          * @param imageUrl
    
19.          *            图像url地址
    
20.          * @param callback
    
21.          *            回调接口
    
22.          * @return 返回内存中缓存的图像，第一次加载返回null
    
23.          */
    
24.         public Drawable loadDrawable(final String imageUrl,
    
25.                         final ImageCallback callback) {
    
26.                 // 如果缓存过就从缓存中取出数据
    
27.                 if (imageCache.containsKey(imageUrl)) {
    
28.                         SoftReference<Drawable> softReference = imageCache.get(imageUrl);
    
29.                         if (softReference.get() != null) {
    
30.                                 return softReference.get();
    
31.                         }
    
32.                 } else if (useTheImage(imageUrl) != null) {
    
33.                         return useTheImage(imageUrl);
    
34.                 }
    
35.                 // 缓存中没有图像，则从网络上取出数据，并将取出的数据缓存到内存中
    
36.                 executorService.submit(new Runnable() {
    
37.                         public void run() {
    
38.                                 try {
    
39.                                         final Drawable drawable = Drawable.createFromStream(
    
40.                                                         new URL(imageUrl).openStream(), "image.png");
    
41.                                         imageCache.put(imageUrl, new SoftReference<Drawable>(
    
42.                                                         drawable));
    
43.                                         handler.post(new Runnable() {
    
44.                                                 public void run() {
    
45.                                                         callback.imageLoaded(drawable);
    
46.                                                 }
    
47.                                         });
    
48.                                         saveFile(drawable, imageUrl);
    
49.                                 } catch (Exception e) {
    
50.                                         throw new RuntimeException(e);
    
51.                                 }
    
52.                         }
    
53.                 });
    
54.                 return null;
    
55.         }
    
56. 
    
57.         // 从网络上取数据方法
    
58.         public Drawable loadImageFromUrl(String imageUrl) {
    
59.                 try {
    
60. 
    
61.                         return Drawable.createFromStream(new URL(imageUrl).openStream(),
    
62.                                         "image.png");
    
63.                 } catch (Exception e) {
    
64.                         throw new RuntimeException(e);
    
65.                 }
    
66.         }
    
67. 
    
68.         // 对外界开放的回调接口
    
69.         public interface ImageCallback {
    
70.                 // 注意 此方法是用来设置目标对象的图像资源
    
71.                 public void imageLoaded(Drawable imageDrawable);
    
72.         }
    
73. 
    
74.         // 引入线程池，并引入内存缓存功能,并对外部调用封装了接口，简化调用过程
    
75.         public void LoadImage(final String url, final ImageView iv) {
    
76.                 if (iv.getImageMatrix() == null) {
    
77.                         iv.setImageResource(R.drawable.loading);
    
78.                 }
    
79.                 // 如果缓存过就会从缓存中取出图像，ImageCallback接口中方法也不会被执行
    
80.                 Drawable cacheImage = loadDrawable(url,
    
81.                                 new AsyncImageLoader.ImageCallback() {
    
82.                                         // 请参见实现：如果第一次加载url时下面方法会执行
    
83.                                         public void imageLoaded(Drawable imageDrawable) {
    
84.                                                 iv.setImageDrawable(imageDrawable);
    
85.                                         }
    
86.                                 });
    
87.                 if (cacheImage != null) {
    
88.                         iv.setImageDrawable(cacheImage);
    
89.                 }
    
90.         }
    
91. 
    
92.         /**
    
93.          * 保存图片到SD卡上
    
94.          *
    
95.          * @param bm
    
96.          * @param fileName
    
97.          *
    
98.          */
    
99.         public void saveFile(Drawable dw, String url) {
    
100.                 try {
     
101.                         BitmapDrawable bd = (BitmapDrawable) dw;
     
102.                         Bitmap bm = bd.getBitmap();
     
103. 
     
104.                         // 获得文件名字
     
105.                         final String fileNa = url.substring(url.lastIndexOf("/") + 1,
     
106.                                         url.length()).toLowerCase();
     
107.                         File file = new File(path + "/image/" + fileNa);
     
108.                         // 创建图片缓存文件夹
     
109.                         boolean sdCardExist = Environment.getExternalStorageState().equals(
     
110.                                         android.os.Environment.MEDIA_MOUNTED); // 判断sd卡是否存在
     
111.                         if (sdCardExist) {
     
112.                                 File maiduo = new File(path);
     
113.                                 File ad = new File(path + "/image");
     
114.                                 // 如果文件夹不存在
     
115.                                 if (!maiduo.exists()) {
     
116.                                         // 按照指定的路径创建文件夹
     
117.                                         maiduo.mkdir();
     
118.                                         // 如果文件夹不存在
     
119.                                 } else if (!ad.exists()) {
     
120.                                         // 按照指定的路径创建文件夹
     
121.                                         ad.mkdir();
     
122.                                 }
     
123.                                 // 检查图片是否存在
     
124.                                 if (!file.exists()) {
     
125.                                         file.createNewFile();
     
126.                                 }
     
127.                         }
     
128. 
     
129.                         BufferedOutputStream bos = new BufferedOutputStream(
     
130.                                         new FileOutputStream(file));
     
131.                         bm.compress(Bitmap.CompressFormat.JPEG, 100, bos);
     
132.                         bos.flush();
     
133.                         bos.close();
     
134.                 } catch (Exception e) {
     
135.                         // TODO: handle exception
     
136.                 }
     
137.         }
     
138. 
     
139.         /**
     
140.          * 使用SD卡上的图片
     
141.          *
     
142.          */
     
143.         public Drawable useTheImage(String imageUrl) {
     
144. 
     
145.                 Bitmap bmpDefaultPic = null;
     
146. 
     
147.                 // 获得文件路径
     
148.                 String imageSDCardPath = path
     
149.                                 + "/image/"
     
150.                                 + imageUrl.substring(imageUrl.lastIndexOf("/") + 1,
     
151.                                                 imageUrl.length()).toLowerCase();
     
152.                 File file = new File(imageSDCardPath);
     
153.                 // 检查图片是否存在
     
154.                 if (!file.exists()) {
     
155.                         return null;
     
156.                 }
     
157.                 bmpDefaultPic = BitmapFactory.decodeFile(imageSDCardPath, null);
     
158. 
     
159.                 if (bmpDefaultPic != null || bmpDefaultPic.toString().length() > 3) {
     
160.                         Drawable drawable = new BitmapDrawable(bmpDefaultPic);
     
161.                         return drawable;
     
162.                 } else
     
163.                         return null;
     
164.         }
     
165. 
     
166. }
     

复制代码