Android 高效加載大圖、多圖解決方案，有效避免程序OOM

本篇文章主要內容來自於 Android Doc，我翻譯之后又做了些加工，英文好的朋友也可以直接去讀原文。
http://developer.android.com/training/displaying-bitmaps/index.html

一、高效加載大圖片

我們在編寫 Android 程序的時候經常要用到許多圖片，不同圖片總是會有不同的形狀、不同的大小，但在大多數情況下，這些圖片都會大於我們程序所需要的大小。比如說系統圖片庫里展示的圖片大都是用手機攝像頭拍出來的，這些圖片的分辨率會比我們手機屏幕的分辨率高得多。大家應該知道，我們編寫的應用程序都是有一定內存限制的，程序占用了過高的內存就容易出現OOM(OutOfMemory)異常。我們可以通過下面的代碼看出每個應用程序最高可用內存是多少。

        int tMaxMemory = (int) (Runtime.getRuntime().maxMemory() / 1024);
        Log.e(TAG, "Max memory is " + tMaxMemory + " KB");
      
【運行結果】
        Max memory is 262144 KB

        int tMaxMemory = (int) (Runtime.getRuntime().maxMemory() / (1024 * 1024));
        Log.e(TAG, "Max memory is " + tMaxMemory + " MB");

【運行結果】
        Max memory is 256 MB

因此在展示高分辨率圖片的時候，最好先將圖片進行壓縮。壓縮后的圖片大小應該和用來展示他的控件大小相近，在一個很小的 ImageView 上顯示一張超大的圖片不會帶來任何視覺上的好處，但卻會占用我們相當多寶貴的內存，而且在性能上還可能會帶來負面影響。下面我們就來看一看，如何對一張大圖片進行適當的壓縮，讓他能夠以最佳大小顯示的同時，還能防止 OOM 的出現。

BitmapFactory 這個類提供了多個解析方法 (decodeByteArray, decodeFile, decodeResource 等) 用於創建 Bitmap 對象，我們應該根據圖片的來源選擇合適的方法。比如 SD 卡中的圖片可以使用 decodeFile 方法，網絡上的圖片可以使用 decodeStream 方法，資源文件中的圖片可以使用 decodeResource 方法。這些方法會嘗試為已經構建的 bitmap 分配內存，這時就會很容易導致 OOM 出現。為此每一種解析方法都提供了一個可選的BitmapFactory.Options 參數，將這個參數的 inJustDecodeBounds 屬性設置為 true 就可以讓解析方法禁止為bitmap 分配內存，返回值也不再是一個 Bitmap 對象，而是 null。雖然 Bitmap 是 null 了，但是BitmapFactory.Options 的 outWidth、outHeight 和 outMimeType 屬性都會被賦值。這個技巧讓我們可以在加載圖片之前就獲取到圖片的長寬值和 MIME 類型，從而根據情況對圖片進行壓縮。如下代碼所示：

        BitmapFactory.Options tOptions = new BitmapFactory.Options();
        tOptions.inJustDecodeBounds = true;
        BitmapFactory.decodeResource(getResources(), R.id.ivMyImage, tOptions);
        int tImageHeight = tOptions.outHeight;
        int tImageWidth = tOptions.outWidth;
        String tImageType = tOptions.outMimeType;

為了避免 OOM 異常，最好在解析每張圖片的時候都先檢查一下圖片的大小，除非你非常信任圖片的來源，保證這些圖片都不會超出你程序的可用內存。

現在圖片的大小已經知道了，我們就可以決定是把整張圖片加載到內存中還是加載一個壓縮版的圖片到內存中。

以下幾個因素是我們需要考慮的：

1.預估一下加載整張圖片所需占用的內存。

2.為了加載這一張圖片你所願意提供多少內存。

3.用於展示這張圖片的控件的實際大小。

4.當前設備的屏幕尺寸和分辨率。

比如，你的 ImageView 只有 128*96 像素的大小，只是為了顯示一張縮略圖，這時候把一張 1024*768 像素的圖片完全加載到內存中顯然是不值得的。

那我們怎樣才能對圖片進行壓縮呢？通過設置 BitmapFactory.Options 中 inSampleSize 的值就可以實現。比如我們有一張 2048*1536 像素的圖片，將 inSampleSize 的值設置為 4，就可以把這張圖片壓縮成 512*384 像素。原本加載這張圖片需要占用 13M 的內存，壓縮后就只需要占用 0.75M了 (假設圖片是 ARGB_8888 類型，即每個像素點占用 4 個字節)。下面的方法可以根據傳入的寬和高，計算出合適的 inSampleSize 值：

    /**
     * 根據傳入的寬和高，計算出合適的 inSampleSize 值
     */
    public static int calculateInSampleSize(BitmapFactory.Options options,
            int reqWidth, int reqHeight) {

        //  源圖片的高度和寬度
        final int tHeight = options.outHeight;
        final int tWidth = options.outWidth;

        int tInSampleSize = 1;
        if (tHeight > reqHeight || tWidth > reqWidth) {

            //  計算出實際寬高和目標寬高的比率  
            final int tHeightRatio = Math.round((float) tHeight
                    / (float) reqHeight);
            final int tWidthRatio = Math.round((float) tWidth
                    / (float) reqWidth);

            /*
             * 選擇寬和高中最小的比率作為inSampleSize的值， 這樣可以保證最終圖片的寬和高，一定都會             * 大於等於目標的寬和高。
             */
            tInSampleSize = tHeightRatio < tWidthRatio ? tHeightRatio
                    : tWidthRatio;
        }
        return tInSampleSize;
    }
  
使用這個方法，首先你要將 BitmapFactory.Options 的 inJustDecodeBounds 屬性設置為 true，解析一次圖片。然后將 BitmapFactory.Options 連同期望的寬度和高度一起傳遞到 calculateInSampleSize 方法中，就可以得到合適的 inSampleSize 值了。之后再解析一次圖片，使用新獲取到的 inSampleSize 值，並把inJustDecodeBounds 設置為 false，就可以得到壓縮后的圖片了。

    /**
     * 根據傳入的寬和高，生成相應大小的縮略圖
     * 
     * @param res
     * @param resId
     * @param reqWidth
     * @param reqHeight
     * @return
     */
    public static Bitmap decodeSampledBitmapFromResource(Resources res,
            int resId, int reqWidth, int reqHeight) {

        // 第一次解析將inJustDecodeBounds設置為true，來獲取圖片大小
        BitmapFactory.Options tOptions = new BitmapFactory.Options();

        tOptions.inJustDecodeBounds = true;
        BitmapFactory.decodeResource(res, resId, tOptions);

        // 調用上面定義的方法計算inSampleSize值
        tOptions.inSampleSize = calculateInSampleSize(tOptions, reqWidth,
                reqHeight);

        // 使用獲取到的inSampleSize值再次解析圖片
        tOptions.inJustDecodeBounds = false;

        return BitmapFactory.decodeResource(res, resId, tOptions);
    }

下面的代碼非常簡單地將任意一張圖片壓縮成 100*100 的縮略圖，並在 ImageView 上展示。

        ImageView tIvMyImage = (ImageView) this.findViewById(R.id.ivMyImage);
        tIvMyImage.setImageBitmap(decodeSampledBitmapFromResource(
                getResources(), R.drawable.camel, 100, 100));

【肖金來親自測試】
一張 2.2MB 大小的圖片，放在 drawable-hdpi 下面，使用原生的 tIvMyImage.setBackgroundResource(R.drawable.camel); 方法加載圖片，根本看不到照片，顯示的是空白。而使用上面的方法，可以顯示出圖片。

二、使用圖片緩存技術

在你應用程序的 UI 界面加載一張圖片是一件很簡單的事情，但是當你需要在界面上加載一大堆圖片的時候，情況就變得復雜起來。在很多情況下，（比如使用 ListView, GridView 或者 ViewPager 這樣的組件），屏幕上顯示的圖片可以通過滑動屏幕等事件不斷地增加，最終導致 OOM。

為了保證內存的使用始終維持在一個合理的范圍，通常會把被移除屏幕的圖片進行回收處理。此時垃圾回收器也會認為你不再持有這些圖片的引用，從而對這些圖片進行 GC 操作。用這種思路來解決問題是非常好的，可是為了能讓程序快速運行，在界面上迅速地加載圖片，你又必須要考慮到某些圖片被回收之后，用戶又將他重新滑入屏幕這種情況。這時重新去加載一遍剛剛加載過的圖片無疑是性能的瓶頸，你需要想辦法去避免這個情況的發生。

這個時候，使用內存緩存技術可以很好的解決這個問題，他可以讓組件快速地重新加載和處理圖片。下面我們就來看一看如何使用內存緩存技術來對圖片進行緩存，從而讓你的應用程序在加載很多圖片的時候可以提高響應速度和流暢性。

內存緩存技術對那些大量占用應用程序寶貴內存的圖片提供了快速訪問的方法。其中最核心的類是 LruCache (此類在 android-support-v4 的包中提供 )。這個類非常適合用來緩存圖片，他的主要算法原理是把最近使用的對象用強引用存儲在 LinkedHashMap 中，並且把最近最少使用的對象在緩存值達到預設定值之前從內存中移除。

在過去，我們經常會使用一種非常流行的內存緩存技術的實現，即軟引用或弱引用 (SoftReference or WeakReference)。但是現在已經不再推薦使用這種方式了，因為從 Android 2.3 (API Level 9)開始，垃圾回收器會更傾向於回收持有軟引用或弱引用的對象，這讓軟引用和弱引用變得不再可靠。另外，Android 3.0 (API Level 11)中，圖片的數據會存儲在本地的內存當中，因而無法用一種可預見的方式將其釋放，這就有潛在的風險造成應用程序的內存溢出並崩潰。

為了能夠選擇一個合適的緩存大小給 LruCache, 有以下多個因素應該放入考慮范圍內，例如：

1.你的設備可以為每個應用程序分配多大的內存？

2.設備屏幕上一次最多能顯示多少張圖片？有多少圖片需要進行預加載，因為有可能很快也會顯示在屏幕上？

3.你的設備的屏幕大小和分辨率分別是多少？一個超高分辨率的設備（例如 Galaxy Nexus) 比起一個較低分辨率的設備（例如 Nexus S），在持有相同數量圖片的時候，需要更大的緩存空間。

4.圖片的尺寸和大小，還有每張圖片會占據多少內存空間。

5.圖片被訪問的頻率有多高？會不會有一些圖片的訪問頻率比其他圖片要高？如果有的話，你也許應該讓一些圖片常駐在內存當中，或者使用多個 LruCache 對象來區分不同組的圖片。

6.你能維持好數量和質量之間的平衡嗎？有些時候，存儲多個低像素的圖片，而在后台去開線程加載高像素的圖片會更加的有效。

並沒有一個指定的緩存大小可以滿足所有的應用程序，這是由你決定的。你應該去分析程序內存的使用情況，然后制定出一個合適的解決方案。一個太小的緩存空間，有可能造成圖片頻繁地被釋放和重新加載，這並沒有好處。而一個太大的緩存空間，則有可能還是會引起 java.lang.OutOfMemory 的異常。

下面是一個使用 LruCache 來緩存圖片的例子：

/**
 * 使用 LruCache 來緩存圖片
 */
public class LruCacheActivity extends Activity {

    private LruCache<String, Bitmap> mMemoryCache;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        initControl();
    }

    private void initControl() {

        /*
         * 獲取到可用內存的最大值，使用內存超出這個值會引起 OutOfMemory 異常。 LruCache通過構造函數傳入緩存值，以KB為單位。
         */
        int tMaxMemory = (int) (Runtime.getRuntime().maxMemory() / 1024);

        // 使用最大可用內存值的1/8作為緩存的大小。
        int tCacheSize = tMaxMemory / 8;

        mMemoryCache = new LruCache<String, Bitmap>(tCacheSize) {

            protected int sizeOf(String key, Bitmap bitmap) {

                // 重寫此方法來衡量每張圖片的大小，默認返回圖片數量。
                return bitmap.getByteCount();
            };
        };
    }

    public void addBitmapToMemoryCache(String key, Bitmap bitmap) {

        if (getBitmapFromCache(key) == null) {

            mMemoryCache.put(key, bitmap);
        }
    }

    public Bitmap getBitmapFromCache(String key) {

        return mMemoryCache.get(key);
    }
}
  
在這個例子當中，使用了系統分配給應用程序的八分之一內存來作為緩存大小。在中高配置的手機當中，這大概會有 4 兆 (32/8) 的緩存空間。一個全屏幕的 GridView 使用 4 張 800x480 分辨率的圖片來填充，則大概會占用 1.5 兆的空間 (800*480*4)。因此，這個緩存大小可以存儲 2.5 頁的圖片。

當向 ImageView 中加載一張圖片時,首先會在 LruCache 的緩存中進行檢查。如果找到了相應的鍵值，則會立刻更新 ImageView，否則開啟一個后台線程來加載這張圖片。

    public void imageLoader(String imagePath,ImageView imageView){
        
        String tImageKey = String.valueOf(imagePath);
        Bitmap tBitmap = getBitmapFromCache(tImageKey);

        if (tBitmap == null) {

            BitmapWorkerTask tBitWorkTask = new BitmapWorkerTask(imageView,mMemoryCache);
            tBitWorkTask.execute(tImageKey);
        } else {

            imageView.setImageBitmap(tBitmap);
        }
    }
  
BitmapWorkerTask 還要把新加載的圖片的鍵值對放到緩存中。

    @Override
    protected Bitmap doInBackground(String... params) {

        String imagePath = getImagePath(params[0]);
        Bitmap tBitmap = null;

        if (imagePath == null || imagePath.equals("")) {

            return null;
        }

        tBitmap = getFileBitmap(imagePath);
        mMemoryCache.put(imagePath, tBitmap);

        return tBitmap;
    }

掌握了以上兩種方法，不管是要在程序中加載超大圖片，還是要加載大量圖片，都不用擔心 OOM 的問題了!不過僅僅是理論地介紹不知道大家能不能完全理解，在后面的文章中我會演示如何在實際程序中靈活運用上述技巧來避免程序 OOM，感興趣的朋友請繼續閱讀 Android照片牆應用實現，再多的圖片也不怕崩潰。

三、自己寫的基於 LruCache 處理圖片主要類代碼

/**
 * 自定義圖片緩存類
 */
public class XjlLruCache {

    private LruCache<String, Bitmap> mMemoryCache;
    
    public XjlLruCache(){
        
        /*
         * 獲取到可用內存的最大值，使用內存超出這個值會引起 OutOfMemory 異常。 LruCache通過構造函數傳入緩存值，以KB為單位。
         */
        int tMaxMemory = (int) (Runtime.getRuntime().maxMemory() / 1024);

        // 使用最大可用內存值的1/8作為緩存的大小。
        int tCacheSize = tMaxMemory / 8;

        mMemoryCache = new LruCache<String, Bitmap>(tCacheSize) {

            protected int sizeOf(String key, Bitmap bitmap) {

                // 重寫此方法來衡量每張圖片的大小，默認返回圖片數量。
                return bitmap.getByteCount();
            };
        };
    }
    
    public void imageLoader(String imagePath,ImageView imageView){
        
        String tImageKey = String.valueOf(imagePath);
        Bitmap tBitmap = getBitmapFromCache(tImageKey);

        if (tBitmap == null) {

            BitmapWorkerTask tBitWorkTask = new BitmapWorkerTask(imageView,mMemoryCache);
            tBitWorkTask.execute(tImageKey);
        } else {

            imageView.setImageBitmap(tBitmap);
        }
    }
    
    public Bitmap getBitmapFromCache(String key) {

        return mMemoryCache.get(key);
    }
}

/**
 * 異步加載緩存圖片
 */
public class BitmapWorkerTask extends AsyncTask<String, Void, Bitmap> {

    private ImageView mImageView;
    private LruCache<String, Bitmap> mMemoryCache;

    private int mReqWidth;
    private int mReqHeight;

    public BitmapWorkerTask() {

    }

    public BitmapWorkerTask(ImageView imageView,
            LruCache<String, Bitmap> mMemoryCache) {

        this.mImageView = imageView;
        this.mMemoryCache = mMemoryCache;

        mReqWidth = imageView.getWidth();
        mReqHeight = imageView.getHeight();
    }

    @Override
    protected Bitmap doInBackground(String... params) {

        String imagePath = getImagePath(params[0]);
        Bitmap tBitmap = null;

        if (imagePath == null || imagePath.equals("")) {

            return null;
        }

        tBitmap = getFileBitmap(imagePath);
        mMemoryCache.put(imagePath, tBitmap);

        return tBitmap;
    }

    @Override
    protected void onPostExecute(Bitmap bitmap) {
        super.onPostExecute(bitmap);

        if (mImageView == null || bitmap == null) {

            mImageView.setBackgroundResource(R.drawable.ic_launcher);
        } else {

            mImageView.setImageBitmap(bitmap);
        }
    }

    /**
     * 獲取圖片路徑
     * 
     * @param string
     * @return
     */
    private String getImagePath(String imagePath) {

        File tFile = new File(imagePath);

        if (tFile.exists()) {

            return tFile.getAbsolutePath();
        } else {

            return null;
        }
    }

    public Bitmap getFileBitmap(String imagePath) {

        // 第一次解析將inJustDecodeBounds設置為true，來獲取圖片大小
        BitmapFactory.Options tOptions = new BitmapFactory.Options();

        tOptions.inJustDecodeBounds = true;
        BitmapFactory.decodeFile(imagePath, tOptions);

        // 調用上面定義的方法計算inSampleSize值
        tOptions.inSampleSize = calculateInSampleSize(tOptions, 100, 100);

        // 使用獲取到的inSampleSize值再次解析圖片
        tOptions.inJustDecodeBounds = false;

        return BitmapFactory.decodeFile(imagePath, tOptions);
    }

    /**
     * 根據傳入的寬和高，計算出合適的 inSampleSize 值
     */
    public int calculateInSampleSize(BitmapFactory.Options options,
            int reqWidth, int reqHeight) {

        // 源圖片的高度和寬度
        final int tHeight = options.outHeight;
        final int tWidth = options.outWidth;

        int tInSampleSize = 1;

        if (tHeight > reqHeight || tWidth > reqWidth) {

            // 計算出實際寬高和目標寬高的比率
            final int tHeightRatio = Math.round((float) tHeight
                    / (float) reqHeight);
            final int tWidthRatio = Math.round((float) tWidth
                    / (float) reqWidth);

            /*
             * 選擇寬和高中最小的比率作為 inSampleSize 的值， 這樣可以保證最終圖片的寬和高，一定都會大於等於目標的寬和高。
             */
            tInSampleSize = tHeightRatio < tWidthRatio ? tHeightRatio
                    : tWidthRatio;
        }
        return tInSampleSize;
    }
}

/**
 * 緩存圖片適配器
 */
public class LruCacheAdapter extends BaseAdapter {

    private List<String> mDatas;
    private LayoutInflater mInflater;
    private XjlLruCache mLruCache;

    public LruCacheAdapter(Context context, List<String> datas) {

        mInflater = LayoutInflater.from(context);
        this.mDatas = datas;

        mLruCache = new XjlLruCache();
    }

    @Override
    public int getCount() {

        return mDatas.size();
    }

    @Override
    public Object getItem(int position) {

        return position;
    }

    @Override
    public long getItemId(int position) {

        return position;
    }

    @Override
    public View getView(int position, View convertView, ViewGroup parent) {

        if (convertView == null) {

            convertView = mInflater.inflate(R.layout.activity_lrucache_item,
                    null);
        }

        ImageView tIvMyImage = (ImageView) convertView
                .findViewById(R.id.ivLruCache);

        mLruCache.imageLoader(mDatas.get(position), tIvMyImage);

        return convertView;
    }
}

/**
 * 自已寫的，基於 LruCache 緩存圖片 Activity
 */
public class LruCacheActivity extends Activity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        initControl(); // 加載控件
    }

    private void initControl() {

        setContentView(R.layout.activity_lrucache);

        List<String> mDatas = new ArrayList<String>();
        for (int i = 1; i < 300; i++) {

            mDatas.add(FileUtils.IMAGE_PATH + "backimg" + i + ".jpg");
        }

        ListView tLvLruCache = (ListView) this.findViewById(R.id.lvLruCache);
        tLvLruCache.setAdapter(new LruCacheAdapter(this, mDatas));
    }
}