Processing Bitmaps Off the UI Thread
非ui线程处理位图。
BitmapFactory.decode*方法，在上一篇讨论过的，不应该在ui线程上处理的情况：从硬盘加载或从网络加载。因为加载时间未知，如果时间过久，会导致程序失去响应。
这章节是关于AsyncTask在后台处理图片的。
AsyncTask类提供了一个简易的方法处理后台事务，并通知ui线程。使用它需要创建一个子类，覆盖一些方法这里举一个加载图片到ImageView的例子：
class BitmapWorkerTask extends AsyncTask {
private final WeakReference imageViewReference;
private int data = 0;
public BitmapWorkerTask(ImageView imageView) {
// Use a WeakReference to ensure the ImageView can be garbage collected
imageViewReference = new WeakReference(imageView);
}
// Decode image in background.
@Override
protected Bitmap doInBackground(Integer... params) {
data = params[0];
return decodeSampledBitmapFromResource(getResources(), data, 100, 100));
}
// Once complete, see if ImageView is still around and set bitmap.
@Override
protected void onPostExecute(Bitmap bitmap) {
if (imageViewReference != null && bitmap != null) {
final ImageView imageView = imageViewReference.get();
if (imageView != null) {
imageView.setImageBitmap(bitmap);
}
}
}
}
WeakReference是为了避免ImageView被回收时由于引用造成无法回收。所以多次判断是否为null值。这种为空的情况如Activity已经到了其它Activity，或配置变化了。
加载图片就简单了：
public void loadBitmap(int resId, ImageView imageView) {
BitmapWorkerTask task = new BitmapWorkerTask(imageView);
task.execute(resId);
}
Handle Concurrency：
ListView,GridView是另一个麻烦的地方，为了有效地使用内存，这些组件会在用户滚动时回收一些子View，如果每一个View都触发一个AsyncTask，不能保证在操作完成时，相关的View还存在。它可能被回收了
http://android-developers.blogspot.com/2010/07/multithreading-for-performance.html 更详细地说明了并发的问题，提供了一个解决办法。存储最近的AsyncTask。
提供专用的Drawable子类来存储task，
static class AsyncDrawable extends BitmapDrawable {
private final WeakReference bitmapWorkerTaskReference;
public AsyncDrawable(Resources res, Bitmap bitmap,
BitmapWorkerTask bitmapWorkerTask) {
super(res, bitmap);
bitmapWorkerTaskReference =
new WeakReference(bitmapWorkerTask);
}
public BitmapWorkerTask getBitmapWorkerTask() {
return bitmapWorkerTaskReference.get();
}
}
在执行BitmapWorkerTask时，先创建一个AsyncDrawable，绑定到相关的ImageView中，
public void loadBitmap(int resId, ImageView imageView) {
if (cancelPotentialWork(resId, imageView)) {
final BitmapWorkerTask task = new BitmapWorkerTask(imageView);
final AsyncDrawable asyncDrawable =
new AsyncDrawable(getResources(), mPlaceHolderBitmap, task);
imageView.setImageDrawable(asyncDrawable);
task.execute(resId);
}
}
cancelPotentialWork方法就是检查是否关联的task已经在运行了。它先调用cancel()结束先前的方法，
public static boolean cancelPotentialWork(int data, ImageView imageView) {
final BitmapWorkerTask bitmapWorkerTask = getBitmapWorkerTask(imageView);
if (bitmapWorkerTask != null) {
final int bitmapData = bitmapWorkerTask.data;
if (bitmapData != data) {
// Cancel previous task
bitmapWorkerTask.cancel(true);
} else {
// The same work is already in progress
return false;
}
}
// No task associated with the ImageView, or an existing task was cancelled
return true;
}
getBitmapWorkerTask这个方法用于关联特定的ImageView
private static BitmapWorkerTask getBitmapWorkerTask(ImageView imageView) {
if (imageView != null) {
final Drawable drawable = imageView.getDrawable();
if (drawable instanceof AsyncDrawable) {
final AsyncDrawable asyncDrawable = (AsyncDrawable) drawable;
return asyncDrawable.getBitmapWorkerTask();
}
}
return null;
}
最后一步是在onPostExecute()确认是否任务结束了和当前的关联ImageView匹配：
class BitmapWorkerTask extends AsyncTask {
...
@Override
protected void onPostExecute(Bitmap bitmap) {
if (isCancelled()) {
bitmap = null;
}
if (imageViewReference != null && bitmap != null) {
final ImageView imageView = imageViewReference.get();
final BitmapWorkerTask bitmapWorkerTask =
getBitmapWorkerTask(imageView);
if (this == bitmapWorkerTask && imageView != null) {
imageView.setImageBitmap(bitmap);
}
}
}
}
这个实现可以用于listview,gridview这样回收他们的子元素的组件中，只要简单地调用loadBitmap方法就可以了。
这里介绍的方法可能的问题是导致很多的线程创建，销毁，这也算是一个问题吧。
Caching Bitmaps 缓存图片
加载单张图片到ui中，比较容易，更复杂一些，一次加载一系列图片。这种情况屏幕上的图片可能通过滚动，不再显示。
一些组件通过回收子元素来回收内存，垃圾回收器释放你已经加载的位图，非长期的引用。这是必须的，但无法提供流畅的体验，你需要避免一直处理这些图片，把它们 贴到屏幕上，内存或硬盘的缓存就可以提供一些帮助了。
Use a Memory Cache
内存缓存提供位图的快速访问，LruCache类（在Support Library中也可用的）
适合缓存位图，保持最近的引用对象，是强引用，清除早期的对象。
SoftReference or WeakReference在之前的版本最好使用这样的引用保存位图，便于回收，3.0版本以前位图是存储在本地内存中的，不容易回收。
不管是哪个版本，都应该使用软引用或弱弱引用，（据说软引用更适合，但这里用弱引用）
对于LruCache的大小选择，有几个因素需要参考的：
你的应用剩下部分需要多数内存？
你需要一次加载多少图片到屏幕上？
屏幕的大小与设备的解析度，高解析度的设备xhdpi像Nexus相比Galaxy S hdpi需要大的缓存来保存相同数量的图片。
维度与配置决定了位图的占用资源的多少。
图片的访问频率。一些比较常用到，另一些不常用，需要保持一些常用的在缓存中，或建多个LruCache对象来存储图片。
在数量与质量间平衡， 有时缓存大量的低分辨率的图片，而加载大图是用后台线程来处理。
对所有没有固定统一的规则，需要自己分析处理。缓存的大小需要自己试验，不同的系统不同的手机需要适配，找到一个合适的值。
下面提供一个使用LruCache的例子：
private LruCache mMemoryCache;
@Override
protected void onCreate(Bundle savedInstanceState) {
...
// Get memory class of this device, exceeding this amount will throw an
// OutOfMemory exception.
final int memClass = ((ActivityManager) context.getSystemService(
Context.ACTIVITY_SERVICE)).getMemoryClass();
// Use 1/8th of the available memory for this memory cache.
final int cacheSize = 1024 * 1024 * memClass / 8;
mMemoryCache = new LruCache(cacheSize) {
@Override
protected int sizeOf(String key, Bitmap bitmap) {
// The cache size will be measured in bytes rather than number of items.
return bitmap.getByteCount();
}
};
...
}
public void addBitmapToMemoryCache(String key, Bitmap bitmap) {
if (getBitmapFromMemCache(key) == null) {
mMemoryCache.put(key, bitmap);
}
}
public Bitmap getBitmapFromMemCache(String key) {
return mMemoryCache.get(key);
}
这个例子中假设hdpi的设备中最小值是4m（32/8），全屏的图片在800*480分辨率中需要消耗1.5m（800*480*4），所以缓存了2.5页图片。
当加载图片时，LruCache会先检查，然后没有才加载其它的图片
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 {
...
// 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;
}
...
}
Use a Disk Cache 磁盘缓存。
内存缓存更快速，当然不能仅靠内存来维持，listview,gridview会很快地占用了内存中的图片，而且你的Activity可能被销毁，然后再加载，这时就需要另一处缓存了。
磁盘缓存主要在下载图片时用到，缓存后不用再次下载，从磁盘中加载当然比从网络中要快得多了
DiskLruCache已经是一种健壮的实现 了，在4.0中提供了源码libcore/luni/src/main/java/libcore/io/DiskLruCache.java,
看个例子：
private DiskLruCache mDiskCache;
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
...
File cacheDir = getCacheDir(this, DISK_CACHE_SUBDIR);
mDiskCache = DiskLruCache.openCache(this, cacheDir, DISK_CACHE_SIZE);
...
}
class BitmapWorkerTask extends AsyncTask {
...
// 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(String.valueOf(imageKey, bitmap);
return 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
if (!mDiskCache.containsKey(key)) {
mDiskCache.put(key, bitmap);
}
}
public Bitmap getBitmapFromDiskCache(String key) {
return mDiskCache.get(key);
}
// 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 getCacheDir(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.getExternalStorageState() == Environment.MEDIA_MOUNTED
|| !Environment.isExternalStorageRemovable() ?
context.getExternalCacheDir().getPath() : context.getCacheDir().getPath();
return new File(cachePath + File.separator + uniqueName);
}
虽然这里没有看到DiskLruCache的源码，但是可以想像得出，前面的章节已经了如何加载图片了。
内存缓存在ui线程中检查，磁盘缓存在后台线程中使用。
未完待续
