注意：在大多數情況下，建議您使用 Glide 程式庫在應用程式中擷取、解碼，並顯示點陣圖。Glide 在處理上述作業，以及其他在 Android 中使用點陣圖和其他圖片的相關任務時，大多能將複雜之處化繁為簡。如要瞭解如何使用和下載 Glide，請造訪 GitHub 的 Glide 存放區。
在使用者介面 (UI) 中載入單一點陣圖的程序相當簡單，但如果需要同時載入一組較大的圖片，操作起來會比較複雜。在許多情況下 (例如使用 ListView、GridView 或 ViewPager 等元件時)，畫面中的圖片與近期將捲動至畫面中的圖片總數，基本上是沒有限制的。
透過這類元件，系統能在子項檢視畫面從畫面中消失時加以回收，進而減少記憶體用量。垃圾收集器會假設您未保留任何長期參照，因此也會釋出已載入的點陣圖。這樣雖然不會有問題，但為了確保 UI 能流暢快速地載入，建議您避免在這些圖片每次重新出現在畫面上時持續處理圖片。記憶體和磁碟快取通常能在這方面派上用場，讓元件可以快速重新載入已處理的圖片。
本課程將逐步引導您使用記憶體和磁碟點陣圖快取，讓 UI 在載入多組點陣圖時能更快反應，運作起來也更流暢。
使用記憶體快取
記憶體快取可讓您快速存取點陣圖，但是可能會耗用大量的應用程式記憶體。LruCache 類別 (也可從支援資料庫取得，最低支援 API 級別 4 版本) 特別適合用於快取點陣圖，以便將近期參照過的物件保留在強式參照的 LinkedHashMap 中，並在快取超過其指定大小前，移除近期使用頻率最低的成員。
注意：在過去，記憶體快取常見的實作方式為 SoftReference 或 WeakReference 點陣圖快取，但我們不建議這麼做。從 Android 2.3 (API 級別 9) 開始，垃圾收集器會更主動地收集導致此類作業效率不彰的軟/弱式參照。此外，在 Android 3.0 (API 級別 11) 之前，點陣圖的備份資料會儲存在並非以預期方式釋出的原生記憶體中，而這可能會導致應用程式短暫超出其記憶體限制並當機。
為了選擇適合 LruCache 的大小，建議您將幾個因素納入考量，例如：
- 其他活動和/或應用程式的記憶體用量有多大？
- 畫面中一次會出現多少張圖片？有多少張圖片需準備好，以便隨時顯示在畫面上？
- 裝置的螢幕大小和密度為何？與 Nexus S (HDPI) 這類裝置相較，超高密度螢幕 (XHDPI) 裝置 (例如 Galaxy Nexus) 需具備更大的快取，才可以在記憶體中保留相同數量的圖片。
- 點陣圖的維度與設定是什麼？分別又會占用多少記憶體？
- 圖片的存取頻率為何？是否有某些圖片的存取頻率較高？如果有，您可能需要將某些特定項目一律保留在記憶體中，甚至讓不同的點陣圖群組有多個
LruCache物件。 - 您是否可以在畫質與數量之間取得平衡？有時候，儲存大量低畫質的點陣圖會比較實用，因為這樣或許能在另一個背景工作中載入較高畫質版本的點陣圖。
目前沒有適用於所有應用程式的特定大小或公式，因此您應自行分析使用情況，找出合適的解決方案。快取如果太小，不但會造成額外負擔，而且沒有益處；快取如果太大，可能會導致再次發生 java.lang.OutOfMemory例外情況，使應用程式的其餘部分沒有足夠的記憶體可用。
以下範例說明如何為點陣圖設定 LruCache：
Kotlin
private lateinit var memoryCache: LruCache<String, Bitmap>
override fun onCreate(savedInstanceState: Bundle?) {
...
// Get max available VM memory, exceeding this amount will throw an
// OutOfMemory exception. Stored in kilobytes as LruCache takes an
// int in its constructor.
val maxMemory = (Runtime.getRuntime().maxMemory() / 1024).toInt()
// Use 1/8th of the available memory for this memory cache.
val cacheSize = maxMemory / 8
memoryCache = object : LruCache<String, Bitmap>(cacheSize) {
override fun sizeOf(key: String, bitmap: Bitmap): Int {
// The cache size will be measured in kilobytes rather than
// number of items.
return bitmap.byteCount / 1024
}
}
...
}
Java
private LruCache<String, Bitmap> memoryCache;
@Override
protected void onCreate(Bundle savedInstanceState) {
...
// Get max available VM memory, exceeding this amount will throw an
// OutOfMemory exception. Stored in kilobytes as LruCache takes an
// int in its constructor.
final int maxMemory = (int) (Runtime.getRuntime().maxMemory() / 1024);
// Use 1/8th of the available memory for this memory cache.
final int cacheSize = maxMemory / 8;
memoryCache = 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;
}
};
...
}
public void addBitmapToMemoryCache(String key, Bitmap bitmap) {
if (getBitmapFromMemCache(key) == null) {
memoryCache.put(key, bitmap);
}
}
public Bitmap getBitmapFromMemCache(String key) {
return memoryCache.get(key);
}
注意：在這個範例中，系統會將八分之一的應用程式記憶體分配給快取，這在一般/HDPI 裝置上最少為 4 MB (32/8) 左右。而在解析度 800x480 的裝置上，全螢幕的 GridView 填滿圖片後會占用約 1.5 MB (800*480*4 位元組) 的空間，因此可以在記憶體中快取至少 2.5 頁的圖片。
將點陣圖載入至 ImageView 時，系統會先檢查 LruCache。如果找到項目，系統會立即透過該項目更新 ImageView；如果沒有找到，則會產生背景執行緒來處理圖片：
Kotlin
fun loadBitmap(resId: Int, imageView: ImageView) {
val imageKey: String = resId.toString()
val bitmap: Bitmap? = getBitmapFromMemCache(imageKey)?.also {
mImageView.setImageBitmap(it)
} ?: run {
mImageView.setImageResource(R.drawable.image_placeholder)
val task = BitmapWorkerTask()
task.execute(resId)
null
}
}
Java
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，才能在記憶體快取中加入項目：
Kotlin
private inner class BitmapWorkerTask : AsyncTask<Int, Unit, Bitmap>() {
...
// Decode image in background.
override fun doInBackground(vararg params: Int?): Bitmap? {
return params[0]?.let { imageId ->
decodeSampledBitmapFromResource(resources, imageId, 100, 100)?.also { bitmap ->
addBitmapToMemoryCache(imageId.toString(), bitmap)
}
}
}
...
}
Java
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;
}
...
}
使用磁碟快取
如要更快速地存取最近檢視過的點陣圖，記憶體快取就能派上用場，但是您不能使用此快取中提供的圖片。GridView 這類含有大型資料集的元件很容易就會用光記憶體快取。而應用程式可能會因通話等其他工作而中斷，且在背景執行時，應用程式可能會遭到終止，記憶體快取則會遭到刪除。使用者繼續操作時，應用程式就必須重新處理每張圖片。
在這些情況下，您可以使用磁碟快取保留已處理的點陣圖，當圖片無法再於記憶體快取中取得時，這種方式有助於縮短載入時間。當然，從磁碟擷取圖片的速度比從記憶體載入慢，而且因為磁碟讀取時間無法預測，所以應在背景執行緒中完成。
注意：如果要經常存取圖片，例如在圖片庫應用程式中存取，ContentProvider 可能會更適合用來儲存快取圖片。
此類別的範例程式碼採用從 Android 來源提取的 DiskLruCache 實作方式。以下是更新的程式碼範例，除了現有記憶體快取之外，還加入了磁碟快取：
Kotlin
private const val DISK_CACHE_SIZE = 1024 * 1024 * 10 // 10MB
private const val DISK_CACHE_SUBDIR = "thumbnails"
...
private var diskLruCache: DiskLruCache? = null
private val diskCacheLock = ReentrantLock()
private val diskCacheLockCondition: Condition = diskCacheLock.newCondition()
private var diskCacheStarting = true
override fun onCreate(savedInstanceState: Bundle?) {
...
// Initialize memory cache
...
// Initialize disk cache on background thread
val cacheDir = getDiskCacheDir(this, DISK_CACHE_SUBDIR)
InitDiskCacheTask().execute(cacheDir)
...
}
internal inner class InitDiskCacheTask : AsyncTask<File, Void, Void>() {
override fun doInBackground(vararg params: File): Void? {
diskCacheLock.withLock {
val cacheDir = params[0]
diskLruCache = DiskLruCache.open(cacheDir, DISK_CACHE_SIZE)
diskCacheStarting = false // Finished initialization
diskCacheLockCondition.signalAll() // Wake any waiting threads
}
return null
}
}
internal inner class BitmapWorkerTask : AsyncTask<Int, Unit, Bitmap>() {
...
// Decode image in background.
override fun doInBackground(vararg params: Int?): Bitmap? {
val imageKey = params[0].toString()
// Check disk cache in background thread
return getBitmapFromDiskCache(imageKey) ?:
// Not found in disk cache
decodeSampledBitmapFromResource(resources, params[0], 100, 100)
?.also {
// Add final bitmap to caches
addBitmapToCache(imageKey, it)
}
}
}
fun addBitmapToCache(key: String, bitmap: Bitmap) {
// Add to memory cache as before
if (getBitmapFromMemCache(key) == null) {
memoryCache.put(key, bitmap)
}
// Also add to disk cache
synchronized(diskCacheLock) {
diskLruCache?.apply {
if (!containsKey(key)) {
put(key, bitmap)
}
}
}
}
fun getBitmapFromDiskCache(key: String): Bitmap? =
diskCacheLock.withLock {
// Wait while disk cache is started from background thread
while (diskCacheStarting) {
try {
diskCacheLockCondition.await()
} catch (e: InterruptedException) {
}
}
return diskLruCache?.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.
fun getDiskCacheDir(context: Context, uniqueName: String): File {
// Check if media is mounted or storage is built-in, if so, try and use external cache dir
// otherwise use internal cache dir
val cachePath =
if (Environment.MEDIA_MOUNTED == Environment.getExternalStorageState()
|| !isExternalStorageRemovable()) {
context.externalCacheDir.path
} else {
context.cacheDir.path
}
return File(cachePath + File.separator + uniqueName)
}
Java
private DiskLruCache diskLruCache;
private final Object diskCacheLock = new Object();
private boolean diskCacheStarting = 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 (diskCacheLock) {
File cacheDir = params[0];
diskLruCache = DiskLruCache.open(cacheDir, DISK_CACHE_SIZE);
diskCacheStarting = false; // Finished initialization
diskCacheLock.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;
}
...
}
public void addBitmapToCache(String key, Bitmap bitmap) {
// Add to memory cache as before
if (getBitmapFromMemCache(key) == null) {
memoryCache.put(key, bitmap);
}
// Also add to disk cache
synchronized (diskCacheLock) {
if (diskLruCache != null && diskLruCache.get(key) == null) {
diskLruCache.put(key, bitmap);
}
}
}
public Bitmap getBitmapFromDiskCache(String key) {
synchronized (diskCacheLock) {
// Wait while disk cache is started from background thread
while (diskCacheStarting) {
try {
diskCacheLock.wait();
} catch (InterruptedException e) {}
}
if (diskLruCache != null) {
return diskLruCache.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);
}
注意：即使是在初始化磁碟快取時，也需要執行磁碟作業，因此不建議在主要執行緒上進行此操作。然而，這也代表在執行初始化前，可能會有存取快取的情形發生。為瞭解決這個問題，我們在上述實作方法中使用鎖定物件，確保在初始化快取之前，應用程式不會從磁碟快取讀取資料。
記憶體快取會在 UI 執行緒中檢查，而磁碟快取則在背景執行緒中檢查。磁碟作業一律不應在 UI 執行緒上進行。圖片處理完畢後，系統會將最終的點陣圖同時加入記憶體和磁碟快取中，以供日後使用。
處理設定變更
執行階段設定變更 (例如螢幕方向變更) 會導致 Android 使用新的設定刪除並重新啟動執行中的活動 (如要進一步瞭解此行為，請參閱「處理執行階段變更」)。您應避免需要再次處理所有圖片的情況，如此一來，當設定變更時，使用者就能享有流暢快速的體驗。
幸運的是，您在「使用記憶體快取」一節中建立了實用的點陣圖記憶體快取。您可以利用呼叫 setRetainInstance(true) 所保留的 Fragment，將此快取傳遞至新的活動執行個體。重新建立活動後，系統會重新附加這個保留的 Fragment，然後您就可以存取現有的快取物件，從而允許快速擷取圖片，並將圖片重新填入至 ImageView 物件中。
以下範例說明如何透過 Fragment 在所有設定變更中保留 LruCache 物件：
Kotlin
private const val TAG = "RetainFragment"
...
private lateinit var mMemoryCache: LruCache<String, Bitmap>
override fun onCreate(savedInstanceState: Bundle?) {
...
val retainFragment = RetainFragment.findOrCreateRetainFragment(supportFragmentManager)
mMemoryCache = retainFragment.retainedCache ?: run {
LruCache<String, Bitmap>(cacheSize).also { memoryCache ->
... // Initialize cache here as usual
retainFragment.retainedCache = memoryCache
}
}
...
}
class RetainFragment : Fragment() {
var retainedCache: LruCache<String, Bitmap>? = null
companion object {
fun findOrCreateRetainFragment(fm: FragmentManager): RetainFragment {
return (fm.findFragmentByTag(TAG) as? RetainFragment) ?: run {
RetainFragment().also {
fm.beginTransaction().add(it, TAG).commit()
}
}
}
}
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
retainInstance = true
}
}
Java
private LruCache<String, Bitmap> memoryCache;
@Override
protected void onCreate(Bundle savedInstanceState) {
...
RetainFragment retainFragment =
RetainFragment.findOrCreateRetainFragment(getFragmentManager());
memoryCache = retainFragment.retainedCache;
if (memoryCache == null) {
memoryCache = new LruCache<String, Bitmap>(cacheSize) {
... // Initialize cache here as usual
}
retainFragment.retainedCache = memoryCache;
}
...
}
class RetainFragment extends Fragment {
private static final String TAG = "RetainFragment";
public LruCache<String, Bitmap> retainedCache;
public RetainFragment() {}
public static RetainFragment findOrCreateRetainFragment(FragmentManager fm) {
RetainFragment fragment = (RetainFragment) fm.findFragmentByTag(TAG);
if (fragment == null) {
fragment = new RetainFragment();
fm.beginTransaction().add(fragment, TAG).commit();
}
return fragment;
}
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setRetainInstance(true);
}
}
如要進行測試，請嘗試在不論是否保留 Fragment 的情況下旋轉裝置。如果保留快取，您應該會發現幾乎沒有延遲，因為圖片是以近乎即時的方式從記憶體填入活動中。而在記憶體快取中找不到的圖片則可能位於磁碟快取中；如果不是的話，系統便會照常處理。