Android bitmap高效显示和优化

第一部分：Bitmap高效显示

应用场景：
有时候我们想在界面上显示一个网络图片或者显示一张本地的图片，
但是图片本身是很大的有几兆，但是显示的位置很小或者说我们可以用更小
的图片来满足这样的需求，如果把整个图片都显示出来会非常的耗内存，甚至可以导致
内存溢出，这就需要我们来处理，如何高效的显示图片，减少内存消耗。

BitmapFactory.Options options = new BitmapFactory.Options();

options.inJustDecodeBounds = true;

BitmapFactory.decodeResource(getResources(), R.id.myimage, options);

int imageHeight = options.outHeight;
int imageWidth = options.outWidth;

String imageType = options.outMimeType;

设置 inJustDecodeBounds 属性为true可以在decoding的时候避免内存的分配，
它会返回一个null的bitmap，
但是 outWidth, outHeight 与 outMimeType 还是可以获取。
这个技术可以允许你在构造bitmap之前优先读图片的尺寸与类型。

将本地一张大图片显示到页面，为了节省内存对图片进行压缩
下面的代码是计算压缩的比例：

public static int calculateInSampleSize(BitmapFactory.Options options, int reqWidth, int reqHeight) {
    // Raw height and width of image
    final int height = options.outHeight;
    final int width = options.outWidth;
    int inSampleSize = 1;

    if (height > reqHeight || width > reqWidth) {

        final int halfHeight = height / 2;
        final int halfWidth = width / 2;

        // Calculate the largest inSampleSize value that is a power of 2 and keeps both
        // height and width larger than the requested height and width.
        while ((halfHeight / inSampleSize) > reqHeight&& (halfWidth / inSampleSize) > reqWidth) {
            inSampleSize *= 2;
        }
    }

    return inSampleSize;
}

 设置inSampleSize为2的幂是因为decoder最终还是会对非2的幂的数进行向下处理，获取到最靠近2的幂的数。

public static Bitmap decodeSampledBitmapFromResource(Resources res, int resId, int reqWidth, int reqHeight) {

    // First decode with inJustDecodeBounds=true to check dimensions
    final BitmapFactory.Options options = new BitmapFactory.Options();
    options.inJustDecodeBounds = true;
    BitmapFactory.decodeResource(res, resId, options);

    // Calculate inSampleSize
    options.inSampleSize = calculateInSampleSize(options, reqWidth, reqHeight);

    // Decode bitmap with inSampleSize set
    options.inJustDecodeBounds = false;
    return BitmapFactory.decodeResource(res, resId, options);
}

为了使用这个方法，首先需要设置 inJustDecodeBounds 为 true,
把options的值传递过来，然后使用 inSampleSize 的值并设置
inJustDecodeBounds 为 false 来重新Decode一遍。

mImageView.setImageBitmap(decodeSampledBitmapFromResource(getResources(), R.id.myimage, 100, 100));

以上就是将一张图片压缩成100*100来显示的，大大的降低了显示原图片所占的内存。


注意：千万要记得，在退出程序，或者退出该界面的时候一定要对生成的bitmap进行回收

 // 先判断是否已经回收  
if(bitmap != null && !bitmap.isRecycled()){  
    // 回收并且置为null  
    bitmap.recycle();  
    bitmap = null;  
}  
System.gc();

第二部分：Bitmap缓存

内存缓存：LruCache类特别适合缓存bitmap的任务，保持最近引用的对象在一个强引用的LinkedHashMap中
，在缓存扩张到指定大小之前，移除最近最少使用的成员

创建LruCache缓存

    private LruCache<String, Bitmap> mMemoryCache;  
      
    @Override  
    protected void onCreate(Bundle savedInstanceState) {  
        ...  
      
        final int maxMemory = (int) (Runtime.getRuntime().maxMemory() / 1024);  //获取系统内存大小
      
       
        final int cacheSize = maxMemory / 8; //设置缓存为内存大小的8分之1 
      
      //初始化缓存
        mMemoryCache = new LruCache<String, Bitmap>(cacheSize) {  
            @Override  
            protected int sizeOf(String key, Bitmap bitmap) {  
           
                return bitmap.getByteCount() / 1024;  
            }  
        };  
        ...  
    }  
      
    public void addBitmapToMemoryCache(String key, Bitmap bitmap) {  
        if (getBitmapFromMemCache(key) == null) {  
            mMemoryCache.put(key, bitmap);  
        }  
    }  
      
    public Bitmap getBitmapFromMemCache(String key) {  
        return mMemoryCache.get(key);  
    }  

加载缓存中的图片：
    当加载一个bitmap到ImageView中的时候，先检查LruCache
如果找到了一个实体，那就马上更新到ImageView上面，否则使用一个后台线程来处理这张图片：

 public void loadBitmap(int resId, ImageView imageView) {  
        final String imageKey = String.valueOf(resId);  
      
        final Bitmap bitmap = getBitmapFromMemCache(imageKey);  
        if (bitmap != null) {  
            mImageView.setImageBitmap(bitmap);  
        } else {  
            mImageView.setImageResource(R.drawable.image_placeholder);  
            BitmapWorkerTask task = new BitmapWorkerTask(mImageView);  
            task.execute(resId);  
        }  
    }  

    BitmapWorkerTask也需要更新来以便加实体到内存缓存中

//缓存中没有图片就需重新加载
    class BitmapWorkerTask extends AsyncTask<Integer, Void, Bitmap> {  
        ...  
        // Decode image in background.  
        @Override  
        protected Bitmap doInBackground(Integer... params) {  
            final Bitmap bitmap = decodeSampledBitmapFromResource(  
                    getResources(), params[0], 100, 100));  
            addBitmapToMemoryCache(String.valueOf(params[0]), bitmap);  
            return bitmap;  
        }  
        ...  
    }  

使用磁盘缓存
    

  创建一个磁盘缓存

 private DiskLruCache mDiskLruCache;  
    private final Object mDiskCacheLock = new Object();  
    private boolean mDiskCacheStarting = true;  
    private static final int DISK_CACHE_SIZE = 1024 * 1024 * 10; // 10MB  
    private static final String DISK_CACHE_SUBDIR = "thumbnails";  
      
    @Override  
    protected void onCreate(Bundle savedInstanceState) {  
        ...  
        // Initialize memory cache  
        ...  
        // Initialize disk cache on background thread  
        File cacheDir = getDiskCacheDir(this, DISK_CACHE_SUBDIR);  //创建缓存目录
        new InitDiskCacheTask().execute(cacheDir);  //创建硬盘缓存
        ...  
    }  
      
      //创建硬盘缓存的线程
    class InitDiskCacheTask extends AsyncTask<File, Void, Void> {  
        @Override  
        protected Void doInBackground(File... params) {  
            synchronized (mDiskCacheLock) {  
                File cacheDir = params[0];  
                mDiskLruCache = DiskLruCache.open(cacheDir, DISK_CACHE_SIZE);  
                mDiskCacheStarting = false; // Finished initialization  
                mDiskCacheLock.notifyAll(); // Wake any waiting threads  
            }  
            return null;  
        }  
    }  
      
      //如果缓存中没有图片就从硬盘加载图片
    class BitmapWorkerTask extends AsyncTask<Integer, Void, Bitmap> {  
        ...  
        // Decode image in background.  
        @Override  
        protected Bitmap doInBackground(Integer... params) {  
            final String imageKey = String.valueOf(params[0]);  
      
            // Check disk cache in background thread  
            Bitmap bitmap = getBitmapFromDiskCache(imageKey);  
      
            if (bitmap == null) { // Not found in disk cache  
                // Process as normal  
                final Bitmap bitmap = decodeSampledBitmapFromResource(  
                        getResources(), params[0], 100, 100));  
            }  
      
            // Add final bitmap to caches  
            addBitmapToCache(imageKey, bitmap);  
      
            return bitmap;  
        }  
        ...  
    }  
      
      //添加bitmap到缓存
    public void addBitmapToCache(String key, Bitmap bitmap) {  
        // Add to memory cache as before  
        if (getBitmapFromMemCache(key) == null) {  
            mMemoryCache.put(key, bitmap);  
        }  
      
        // Also add to disk cache  
        synchronized (mDiskCacheLock) {  
            if (mDiskLruCache != null && mDiskLruCache.get(key) == null) {  
                mDiskLruCache.put(key, bitmap);  
            }  
        }  
    }  
      
      //获取缓存的bitmap
    public Bitmap getBitmapFromDiskCache(String key) {  
        synchronized (mDiskCacheLock) {  
            // Wait while disk cache is started from background thread  
            while (mDiskCacheStarting) {  
                try {  
                    mDiskCacheLock.wait();  
                } catch (InterruptedException e) {}  
            }  
            if (mDiskLruCache != null) {  
                return mDiskLruCache.get(key);  
            }  
        }  
        return null;  
    }  
      
    //创建缓存目录的方法
    // Creates a unique subdirectory of the designated app cache directory. Tries to use external  
    // but if not mounted, falls back on internal storage.  
    public static File getDiskCacheDir(Context context, String uniqueName) {  
        // Check if media is mounted or storage is built-in, if so, try and use external cache dir  
        // otherwise use internal cache dir  
        final String cachePath =  
                Environment.MEDIA_MOUNTED.equals(Environment.getExternalStorageState()) ||  
                        !isExternalStorageRemovable() ? getExternalCacheDir(context).getPath() :  
                                context.getCacheDir().getPath();  
      
        return new File(cachePath + File.separator + uniqueName);  
    }