android读取大图片并缓存

  最近开发电视版的云存储应用，要求”我的相册“模块有全屏预览图片的功能，全屏分辨率是1920*1080超清。

UI组件方面采用Gallery+ImageSwitcher组合，这里略过，详情参见google Android API。

相册图片预取缓存策略是内存缓存（硬引用LruCache、软引用SoftReference<Bitmap>）、外部文件缓存（context.getCachedDir()），缓存中取不到的情况下再向服务端请求下载图片。同时缓存三张图片（当前预览的这张，前一张以及后一张）。

1.内存缓存

//需要导入外部jar文件 android-support-v4.jar
    import android.support.v4.util.LruCache;
    //开辟8M硬缓存空间
    private final int hardCachedSize = 8*1024*1024;
    //hard cache
    private final LruCache<String, Bitmap> sHardBitmapCache = new LruCache<String, Bitmap>(hardCachedSize){
        @Override
        public int sizeOf(String key, Bitmap value){
            return value.getRowBytes() * value.getHeight();
        }
        @Override
        protected void entryRemoved(boolean evicted, String key, Bitmap oldValue, Bitmap newValue){
            Log.v("tag", "hard cache is full , push to soft cache");
            //硬引用缓存区满，将一个最不经常使用的oldvalue推入到软引用缓存区
            sSoftBitmapCahe.put(key, new SoftReference<Bitmap>(oldValue));
        }
    }
    //软引用
    private static final int SOFT_CACHE_CAPACITY = 40;
    private final static LinkedHashMap<String, SoftReference<Bitmap>> sSoftBitmapCache =
        new  LinkedHashMao<String, SoftReference<Bitmap>>(SOFT_CACHE_CAPACITY, 0.75f, true){
        @Override
        public SoftReference<Bitmap> put(String key, SoftReference<Bitmap> value){
            return super.input(key, value);
        }
        @Override
        protected boolean removeEldestEntry(LinkedHashMap.Entry<Stirng, SoftReference<Bitmap>> eldest){
            if(size() > SOFT_CACHE_CAPACITY){
                Log.v("tag", "Soft Reference limit , purge one");
                return true;
            }
            return false;
        }
    }
    //缓存bitmap
    public boolean putBitmap(String key, Bitmap bitmap){
        if(bitmap != null){
            synchronized(sHardBitmapCache){
                sHardBitmapCache.put(key, bitmap);
            }
            return true;
        }
        return false;
    }
    //从缓存中获取bitmap
    public Bitmap getBitmap(String key){
        synchronized(sHardBitmapCache){
            final Bitmap bitmap = sHardBitmapCache.get(key);
            if(bitmap != null)
                return bitmap;
        }
        //硬引用缓存区间中读取失败，从软引用缓存区间读取
        synchronized(sSoftBitmapCache){
            SoftReference<Bitmap> bitmapReference = sSoftBtimapCache.get(key);
            if(bitmapReference != null){
                final Bitmap bitmap2 = bitmapReference.get();
                if(bitmap2 != null)
                    return bitmap2;
                else{
                    Log.v("tag", "soft reference 已经被回收");
                    sSoftBitmapCache.remove(key);
                }
            }
        }
        return null;
    }

2.外部文件缓存

private File mCacheDir = context.getCacheDir();
    private static final int MAX_CACHE_SIZE = 20 * 1024 * 1024; //20M
    private final LruCache<String, Long> sFileCache = new LruCache<String, Long>(MAX_CACHE_SIZE){
        @Override
        public int sizeOf(String key, Long value){
            return value.intValue();
        }
        @Override
        protected void entryRemoved(boolean evicted, String key, Long oldValue, Long newValue){
            File file = getFile(key);
            if(file != null)
                file.delete();
        }
    }
    private File getFile(String fileName) throws FileNotFoundException {
        File file = new File(mCacheDir, fileName);
        if(!file.exists() || !file.isFile())
            throw new FileNotFoundException("文件不存在或有同名文件夹");
        return file;
    }
    //缓存bitmap到外部存储
    public boolean putBitmap(String key, Bitmap bitmap){
        File file = getFile(key);
        if(file != null){
            Log.v("tag", "文件已经存在");
            return true;
        }
        FileOutputStream fos = getOutputStream(key);
        boolean saved = bitmap.compress(CompressFormat.JPEG, 100, fos);
        fos.flush();
        fos.close();
        if(saved){
            synchronized(sFileCache){
                sFileCache.put(key, getFile(key).length());
            }
            return true;
        }
        return false;
    }
    //根据key获取OutputStream
    private FileOutputStream getOutputStream(String key){
        if(mCacheDir == null)
            return null;
        FileOutputStream fos = new FileOutputStream(mCacheDir.getAbsolutePath() + File.separator + key);
        return fos;
    }
    //获取bitmap
    private static BitmapFactory.Options sBitmapOptions;
    static {
        sBitmapOptions = new BitmapFactory.Options();
        sBitmapOptions.inPurgeable=true; //bitmap can be purged to disk
    }
    public Bitmap getBitmap(String key){
        File bitmapFile = getFile(key);
        if(bitmapFile != null){
            Bitmap bitmap = BitmapFactory.decodeStream(new FileInputStream(bitmapFile), null, sBitmapOptions);
            if(bitmap != null){
                //重新将其缓存至硬引用中
                ...
            }
        }
    }

3.从服务端下载图片

下载成功后调用1内存缓存的putBitmap()函数,缓存图片。

在外部文件缓存中也写入一份，调用2的putBitmap()函数.

4.预览图片的流程

1) 如果预览的图片在内存缓存区中，直接调用1的getBitmap()函数，获取bitmap数据(先在硬引用缓存区查找匹配，若硬引用区匹配失败，再去软引用区匹配)

2) 如果从内存缓存区读取失败，再从外部文件缓存中读取，调用2的getBitmap()函数

3) 如果从外部文件缓存中读取失败，则从服务端下载该图片，过程3.

5.生成key值

private static String generateKey(String fileId, int width, int height) {
        String ret = fileId + "_" + Integer.toString(width) + "x" + Integer.toString(height);
        return ret;
    }
    String key = generateKey(...)即可生成唯一的key值

原文地址：http://blog.csdn.net/liliang497/article/details/7221110