高效地加载图片(四) 管理缓存

private int mCacheRefCount = 0;
private int mDisplayRefCount = 0;
...
// 通知当前Drawable,当前被使用的状态改变了
// 保持一个计数器,用来决定当前Drawable何时被回收
public void setIsDisplayed(boolean isDisplayed) {
    synchronized (this) {
        if (isDisplayed) {
			// 当被显示时,则计数器mDisplayRefCount的值+1
            mDisplayRefCount++;
			// 标志当前Drawable被显示了
            mHasBeenDisplayed = true;
        } else {
			// 当一个引用被释放时,计数器mDisplayRefCount的值-1
            mDisplayRefCount--;
        }
    }
    // 确认recycle()方法是否已经被调用了
    checkState();
}

// 通知当前Drawable缓存状态改变了
// 保持一个计数器用于决定何时这个Drawable不再被缓存
public void setIsCached(boolean isCached) {
    synchronized (this) {
        if (isCached) {
            mCacheRefCount++;
        } else {
            mCacheRefCount--;
        }
    }
    // 确认recycle()方法是否已经被调用了
    checkState();
}

private synchronized void checkState() {
	// 如果当前Drawable的内存和展示计数器都为0,而且当前Drawable还可用
	// 则释放掉它
    if (mCacheRefCount <= 0 && mDisplayRefCount <= 0 && mHasBeenDisplayed
            && hasValidBitmap()) {
        getBitmap().recycle();
    }
}

// 判断Drawable对应的Bitmap是否可用
private synchronized boolean hasValidBitmap() {
    Bitmap bitmap = getBitmap();
    return bitmap != null && !bitmap.isRecycled();
}

Set<SoftReference<Bitmap>> mReusableBitmaps;
private LruCache<String, BitmapDrawable> mMemoryCache;

// 当程序运行在Honeycomb(Android 3.1)及以上版本的系统中时,创建一个
// 同步的HashSet用于存放可复用的Bitmap的引用
if (Utils.hasHoneycomb()) {
    mReusableBitmaps =
            Collections.synchronizedSet(new HashSet<SoftReference<Bitmap>>());
}

mMemoryCache = new LruCache<String, BitmapDrawable>(mCacheParams.memCacheSize) {

    // Notify the removed entry that is no longer being cached.
    @Override
    protected void entryRemoved(boolean evicted, String key,
            BitmapDrawable oldValue, BitmapDrawable newValue) {
        if (RecyclingBitmapDrawable.class.isInstance(oldValue)) {
			// 如果被移除的Drawable是RecyclingBitmapDrawable,则通知它
			// 已经被从内存缓存中移除
            ((RecyclingBitmapDrawable) oldValue).setIsCached(false);
        } else {
			// 如果被移除的Drawable是一个普通的BitmapDrawable
            if (Utils.hasHoneycomb()) {
				// 如果运行在Honeycomb(Android 3.1)及以上系统中,则为Bitmap添加
				// 到一个保存软引用的集合中,以备后来被inBitmap使用
                mReusableBitmaps.add
                        (new SoftReference<Bitmap>(oldValue.getBitmap()));
            }
        }
    }
....
}

public static Bitmap decodeSampledBitmapFromFile(String filename,
        int reqWidth, int reqHeight, ImageCache cache) {

    final BitmapFactory.Options options = new BitmapFactory.Options();
    ...
    BitmapFactory.decodeFile(filename, options);
    ...

	// 如果应用运行在Honeycomb及以上系统中,则尝试使用inBitmap复用图片
    if (Utils.hasHoneycomb()) {
        addInBitmapOptions(options, cache);
    }
    ...
    return BitmapFactory.decodeFile(filename, options);
}

private static void addInBitmapOptions(BitmapFactory.Options options,
        ImageCache cache) {
	// inBitmap仅能接受可编辑的Bitmap,所以此处需要强制解码器
	// 返回一个可编辑的Bitmap
    options.inMutable = true;

    if (cache != null) {
		// 尝试查找满足条件的Bitmap给inBitmap赋值
        Bitmap inBitmap = cache.getBitmapFromReusableSet(options);

        if (inBitmap != null) {
			// 如果查找到了符合条件的Bitmap,则赋值给inBitmap
            options.inBitmap = inBitmap;
        }
    }
}

// 这个方法遍历了保存弱引用的集合,用于查找一个合适的Bitmap
protected Bitmap getBitmapFromReusableSet(BitmapFactory.Options options) {
        Bitmap bitmap = null;

    if (mReusableBitmaps != null && !mReusableBitmaps.isEmpty()) {
        synchronized (mReusableBitmaps) {
            final Iterator<SoftReference<Bitmap>> iterator
                    = mReusableBitmaps.iterator();
            Bitmap item;

            while (iterator.hasNext()) {
                item = iterator.next().get();

                if (null != item && item.isMutable()) {
					// 检查当前的Bitmap是否满足inBitmap的复用条件
                    // Check to see it the item can be used for inBitmap.
                    if (canUseForInBitmap(item, options)) {
						// 如果满足复用条件,则给Bitmap赋值,并在方法结束时返回
                        bitmap = item;
						// 在给返回值赋值后,将当前Bitmap的引用从集合中移除
                        iterator.remove();
                        break;
                    }
                } else {
					// 如果读取到的是空引用,则将该引用移除
                    iterator.remove();
                }
            }
        }
    }
    return bitmap;
}

static boolean canUseForInBitmap(
        Bitmap candidate, BitmapFactory.Options targetOptions) {

    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
		// 从Android 4.4(KitKat)开始,如果当前需要的Bitmap尺寸(内存中占用的字节数)比缓存中的Bitmap尺寸小
		// 并且同一张图片的Bitmap存在,我们就可以复用它
        int width = targetOptions.outWidth / targetOptions.inSampleSize;
        int height = targetOptions.outHeight / targetOptions.inSampleSize;
		// 当前需要的Bitmap占用字节数
        int byteCount = width * height * getBytesPerPixel(candidate.getConfig());
		// 如果需要的Bitmap尺寸小于原Bitmap,则返回true
        return byteCount <= candidate.getAllocationByteCount();
    }

	// 在Android 4.4以前,尺寸必须完全一致,并且inSampleSize为1时
	// Bitmap才能被复用
    return candidate.getWidth() == targetOptions.outWidth
            && candidate.getHeight() == targetOptions.outHeight
            && targetOptions.inSampleSize == 1;
}

/**
 * 一个用于判断在不同的参数下,每个像素占用字节数的方法
 */
static int getBytesPerPixel(Config config) {
    if (config == Config.ARGB_8888) {
        return 4;
    } else if (config == Config.RGB_565) {
        return 2;
    } else if (config == Config.ARGB_4444) {
        return 2;
    } else if (config == Config.ALPHA_8) {
        return 1;
    }
    return 1;
}