高效地加载图片(三) 缓存图片

private LruCache<String, Bitmap> mMemoryCache;

@Override
protected void onCreate(Bundle savedInstanceState) {
    ...
	// 获取最大的可用空间,如果需要的空间超出这个大小,则会抛出OutOfMemory异常
	// LrcCache构造函数中的参数是以千字节为单位的
    final int maxMemory = (int) (Runtime.getRuntime().maxMemory() / 1024);

	// 此处缓存大小取可用内存的1/8
    final int cacheSize = maxMemory / 8;

    mMemoryCache = new LruCache<String, Bitmap>(cacheSize) {
        @Override
        protected int sizeOf(String key, Bitmap bitmap) {
            // The cache size will be measured in kilobytes rather than
            // number of items.
			// 缓存的大小会使用千字节来衡量
            return bitmap.getByteCount() / 1024;
        }
    };
    ...
}

// 将Bitmap存入缓存
public void addBitmapToMemoryCache(String key, Bitmap bitmap) {
    if (getBitmapFromMemCache(key) == null) {
		// 当使用(getBitmapFromMemCache方法,根据传入的key获取Bitmap
		// 当获取到的Bitmap为空时,证明没有存储过该Bitmap
		// 此时将该Bitmap存储到LrcCache中
        mMemoryCache.put(key, bitmap);
    }
}

// 根据key从LrcCache中获取对应的Bitmap
public Bitmap getBitmapFromMemCache(String key) {
    return mMemoryCache.get(key);
}

public void loadBitmap(int resId, ImageView imageView) {
	// 将图片的资源id转换为String型,作为key
    final String imageKey = String.valueOf(resId);

	// 根据key从LruCache中获取Bitmap
    final Bitmap bitmap = getBitmapFromMemCache(imageKey);
    if (bitmap != null) {
		// 如果获取到的Bitmap不为空
		// 则直接将获取到的Bitmap更新到ImageView中
        mImageView.setImageBitmap(bitmap);
    } else {
		// 否则,则先在ImageView中设置一张占位图
        mImageView.setImageResource(R.drawable.image_placeholder);
		// 再开启一个新的异步任务去加载图片
        BitmapWorkerTask task = new BitmapWorkerTask(mImageView);
        task.execute(resId);
    }
}

class BitmapWorkerTask extends AsyncTask<Integer, Void, Bitmap> {
    ...
    // 在后台加载图片
    @Override
    protected Bitmap doInBackground(Integer... params) {
        final Bitmap bitmap = decodeSampledBitmapFromResource(
                getResources(), params[0], 100, 100));
		// 将Bitmap对象以键值对的形式存储到LrcCache中
        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) {
    ...
	// 初始化内存缓存
    ...
    // 在后台线程初始化磁盘缓存
    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; // 标识结束初始化
            mDiskCacheLock.notifyAll(); // 唤醒等待中的线程
        }
        return null;
    }
}

class BitmapWorkerTask extends AsyncTask<Integer, Void, Bitmap> {
    ...
    // 在后台解析图片
    @Override
    protected Bitmap doInBackground(Integer... params) {
        final String imageKey = String.valueOf(params[0]);

        // 在后台线程中判断图片是否已经存在于磁盘缓存中
        Bitmap bitmap = getBitmapFromDiskCache(imageKey);

        if (bitmap == null) { // 不存在于磁盘缓存中
            // 则正常加载图片
            final Bitmap bitmap = decodeSampledBitmapFromResource(
                    getResources(), params[0], 100, 100));
        }

        // 将加载出的图片添加到缓存中
        addBitmapToCache(imageKey, bitmap);

        return bitmap;
    }
    ...
}

public void addBitmapToCache(String key, Bitmap bitmap) {
	// 将图片添加到内存缓存中
    if (getBitmapFromMemCache(key) == null) {
        mMemoryCache.put(key, bitmap);
    }

    // 同时将图片添加到磁盘缓存中
    synchronized (mDiskCacheLock) {
        if (mDiskLruCache != null && mDiskLruCache.get(key) == null) {
            mDiskLruCache.put(key, bitmap);
        }
    }
}

public Bitmap getBitmapFromDiskCache(String key) {
    synchronized (mDiskCacheLock) {
		// 当磁盘缓存正在初始化时,则等待
        while (mDiskCacheStarting) {
            try {
                mDiskCacheLock.wait();
            } catch (InterruptedException e) {}
        }
        if (mDiskLruCache != null) {
            return mDiskLruCache.get(key);
        }
    }
    return null;
}

// 当外部存储器可用时,则在应用指定文件夹中创建一个唯一的子文件夹作为缓存目录
// 而当外部设备不可用时,则使用内置存储器
public static File getDiskCacheDir(Context context, String uniqueName) {
	// 检查外部存储器是否可用,如果可用则使用外部存储器的缓存目录
	// 否则使用内部存储器的缓存目录
    final String cachePath =
            Environment.MEDIA_MOUNTED.equals(Environment.getExternalStorageState()) ||
                    !isExternalStorageRemovable() ? getExternalCacheDir(context).getPath() :
                            context.getCacheDir().getPath();

    return new File(cachePath + File.separator + uniqueName);
}

private LruCache<String, Bitmap> mMemoryCache;

@Override
protected void onCreate(Bundle savedInstanceState) {
    ...
	// 得到一个用于保存LruCache的Fragment
    RetainFragment retainFragment =
            RetainFragment.findOrCreateRetainFragment(getFragmentManager());
	// 取出Fragment的LruCache
    mMemoryCache = retainFragment.mRetainedCache;
    if (mMemoryCache == null) {
		// 如果LruCache为空,则原先没有缓存
		// 需要新建并初始化一个LruCache
        mMemoryCache = new LruCache<String, Bitmap>(cacheSize) {
            ... // Initialize cache here as usual
        }
		// 将新建的LruCache存放到Fragment中
        retainFragment.mRetainedCache = mMemoryCache;
    }
    ...
}

class RetainFragment extends Fragment {
    private static final String TAG = "RetainFragment";
    public LruCache<String, Bitmap> mRetainedCache;

    public RetainFragment() {}
	
	// 新建或者从FragmentManager中得到保存LruCache的Fragment
    public static RetainFragment findOrCreateRetainFragment(FragmentManager fm) {
		// 根据tag从FragmentManager中获取对应的Fragment
        RetainFragment fragment = (RetainFragment) fm.findFragmentByTag(TAG);
        if (fragment == null) {
			// 如果Fragment为空,则原先没有该Fragment
			// 即表明原先没有LruCache
			// 此时需要新建一个Fragment用于存放LruCache
            fragment = new RetainFragment();
			// 并将Fragment添加到FragmentManager中
            fm.beginTransaction().add(fragment, TAG).commit();
        }
        return fragment;
    }

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
		// 设置当Activity被重建时,Fragment重新依附到Activity上
        setRetainInstance(true);
    }
}