Uwaga: w większości przypadków zalecamy że używasz Glide, do pobierania, dekodowania i wyświetlania map bitowych w aplikacji. Wyciągnij abstrakcje z większości radzenia sobie z tymi i innymi innych zadań związanych z pracą z mapami bitowymi i innymi obrazami na Androidzie. Informacje o używaniu i pobieraniu Glide znajdziesz na stronie Repozytorium Glide w GitHubie.
Załadowanie pojedynczej mapy bitowej do interfejsu użytkownika jest proste, ale gdy trzeba załadować większą liczbę obrazów naraz, sytuacja się komplikuje. W wielu przypadkach (np.
komponentów takich jak ListView, GridView lub ViewPager), łączną liczbę obrazów na ekranie razem z obrazami, które
które mogą wkrótce przewijać się na ekran, są w zasadzie nieograniczone.
Komponenty takie jak to ograniczają wykorzystanie pamięci przez recykling widoków dziecka, gdy się poruszają. Moduł czyszczenia pamięci uwalnia też załadowane mapy bitowe, zakładając, że żadne długotrwałe odniesienia. To wszystko jest w porządku, ale aby interfejs był płynny i szybko ładujący się, chcesz uniknąć ciągłego przetwarzania tych obrazów za każdym razem, gdy wracają na ekran. Wspomnienie i pamięć podręczna dysku często może pomóc, umożliwiając komponentom szybkie ponowne załadowanie przetworzonych obrazów.
W tej lekcji dowiesz się, jak używać pamięci i pamięci podręcznej bitmap na dysku, aby poprawić responsywność i płynność interfejsu podczas wczytywania wielu bitmap.
Używaj pamięci podręcznej
Pamięć podręczna zapewnia szybki dostęp do map bitowych i wymaga zajmowania cennej aplikacji
pamięci. Klasa LruCache (dostępna też w bibliotece pomocy do użytku publicznego
do poziomu interfejsu API poziomu 4) jest szczególnie przydatny do buforowania map bitowych,
obiekty z odwołanymi obiektami w silnym, przywoływanym elemencie LinkedHashMap, usuwając najmniejsze
ostatnio używany element, zanim pamięć podręczna przekroczy wyznaczony rozmiar.
Uwaga: w przeszłości popularną implementacją pamięci podręcznej była
SoftReference lub WeakReference pamięć podręczna map bitowych,
nie jest to jednak zalecane. Od Androida 2.3 (poziom interfejsu API 9) funkcja czyszczenia pamięci jest
agresywnie gromadząc „delikatne”/słabe odniesienia, przez co są one dość nieskuteczne. Ponadto:
przed Androidem 3.0 (poziom interfejsu API 11) dane kopii zapasowej bitmapy były przechowywane w pamięci natywnej, która
nie jest wydawana w przewidywalny sposób, co może spowodować, że aplikacja
limity pamięci i awarie.
Aby wybrać odpowiedni rozmiar dla urządzenia LruCache, weź pod uwagę kilka czynników
należy wziąć pod uwagę, na przykład:
- Jak intensywnie korzysta się z pamięci w pozostałej części aktywności i aplikacji?
- Ile obrazów jest widocznych na ekranie jednocześnie? Ile filmów musi być dostępnych i gotowych na ekranie?
- Jaki jest rozmiar ekranu i gęstość ekranu urządzenia? Bardzo duże urządzenie z ekranem o dużej gęstości (xhdpi) takie jak Galaxy Nexus, większą pamięć podręczną, by przechowywać w pamięci taką samą liczbę obrazów niż w przypadku urządzeń takich jak Nexus S (hdpi).
- jakie wymiary i konfiguracja są mapami bitowymi, a tym samym ile pamięci zajmuje każda z nich; w górę?
- Jak często będzie uzyskiwany dostęp do obrazów? Czy niektóre z nich będą używane częściej niż inne?
Jeśli tak, być może warto zachować określone elementy zawsze w pamięci, a nawet mieć kilka obiektów
LruCachedla różnych grup map bitowych. - Czy potrafisz zachować równowagę między jakością a ilością? Czasami lepiej jest przechowywać większą liczba map bitowych o niższej jakości, potencjalnie ładowanie wersji wyższej jakości w innej w tle.
Nie istnieje konkretna formuła, która sprawdzi się we wszystkich zastosowaniach, ale to od Ciebie zależy
i znalezieniu odpowiedniego rozwiązania. Zbyt mała pamięć podręczna powoduje dodatkowe obciążenie
brak korzyści, zbyt duża pamięć podręczna może ponownie powodować java.lang.OutOfMemory wyjątków
a większą ilość pamięci zostawić w aplikacji.
Oto przykład konfigurowania LruCache dla bitmap:
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);
}
Uwaga: w tym przykładzie jedna ósma pamięci aplikacji to
przeznaczonych dla naszej pamięci podręcznej. W przypadku zwykłych urządzeń/urządzeń hdpi jest to minimum ok. 4MB (32/8). Pełny ekran GridView wypełniony obrazami na urządzeniu o rozdzielczości 800 × 480 zajmie około 1,5 MB (800 × 480 × 4 bajty), więc w pamięci podręcznej zmieści się co najmniej około 2,5 strony obrazów.
Podczas wczytywania bitmapy do komponentu ImageView tag LruCache
jest sprawdzane najpierw. Po znalezieniu wpisu jest on natychmiast używany do aktualizacji elementu ImageView. W przeciwnym razie w celu przetworzenia obrazu generowany jest wątek tła:
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 również musi być:
Zaktualizowano, aby dodać wpisy do pamięci podręcznej:
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;
}
...
}
Używaj pamięci podręcznej dysku
Pamięć podręczna jest przydatna do przyspieszania dostępu do ostatnio wyświetlanych bitmap, ale nie można polegać na tym, że obrazy będą dostępne w tej pamięci. Komponenty takie jak GridView z
duże zbiory danych mogą
łatwo zapełniać pamięć podręczną. Aplikacja może zostać przerwana przez inną czynność, np. rozmowę telefoniczną, a podczas działania w tle może zostać zamknięta i utracić pamięć podręczną. Gdy użytkownik wznowi swoje działanie, aplikacja będzie musiała przetworzyć wszystkie obrazy ponownie.
W takich przypadkach można użyć pamięci podręcznej dysku, aby utrzymać przetworzone mapy bitowe i przyspieszyć wczytywanie przypadków, gdy obrazy nie są już dostępne w pamięci podręcznej. Oczywiście pobieram zdjęcia z dysku. jest wolniejsze niż ładowanie z pamięci i powinno zostać wykonane w wątku w tle, ponieważ odczyty z dysku mogą być nieprzewidywalne.
Uwaga: wartość ContentProvider może być większa
odpowiednie miejsce do przechowywania obrazów w pamięci podręcznej, jeśli są one częściej używane, na przykład
galerii obrazów.
Przykładowy kod tej klasy korzysta z implementacji DiskLruCache pobieranej z
Źródło Androida.
Oto zaktualizowany przykładowy kod, który dodaje pamięć podręczną dysku do istniejącej pamięci podręcznej:
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);
}
Uwaga: nawet zainicjowanie pamięci podręcznej dysku wymaga operacji na dysku i dlatego nie powinny się odbywać w wątku głównym. Oznacza to jednak, że istnieje dostęp do pamięci podręcznej przed jej zainicjowaniem. Aby rozwiązać ten problem, w powyższym wdrożeniu obiekt blokady zapewnia, że aplikacja nie odczytuje z pamięci podręcznej na dysku, dopóki nie zostanie ona zainicjalizowana.
Gdy pamięć podręczna pamięci jest sprawdzona w wątku interfejsu użytkownika, pamięć podręczna dysku jest sprawdzana w tle w wątku. Operacje dyskowe nie powinny nigdy odbywać się w wątku interfejsu użytkownika. Gdy przetwarzanie obrazu jest zakończono, ostateczna mapa bitowa jest dodawana do pamięci podręcznej oraz podręcznej pamięci dyskowej w celu użycia w przyszłości.
Obsługa zmian konfiguracji
Zmiany konfiguracji w czasie wykonywania, takie jak zmiana orientacji ekranu, powodują, że Android niszczy bieżącą aktywność i uruchamia ją ponownie z nową konfiguracją (więcej informacji o tym zachowaniu znajdziesz w artykule Przetwarzanie zmian w czasie wykonywania). Chcesz uniknąć konieczności ponownego przetwarzania wszystkich obrazów, aby użytkownik miał płynne i szybkie wrażenia podczas zmiany konfiguracji.
Na szczęście masz sporą pamięć podręczną z mapami bitowymi, która została wbudowana w sekcji Użyj pamięci podręcznej. Ta pamięć podręczna może zostać przekazana nowej instancji aktywności za pomocą obiektu Fragment, który jest zachowany przez wywołanie setRetainInstance(true). Po zakończeniu aktywności
ten zachowany zasób Fragment zostanie ponownie podłączony i uzyskasz dostęp do
istniejący obiekt pamięci podręcznej, co umożliwia szybkie pobieranie i ponowne wypełnianie obrazów w obiektach ImageView.
Oto przykład zachowywania obiektu LruCache w różnych konfiguracjach
zmienia się za pomocą parametru Fragment:
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);
}
}
Aby to sprawdzić, obróć urządzenie zarówno z zachowaniem elementu Fragment, jak i bez niego. Opóźnienie powinno być niewielkie lub zerowe, ponieważ obrazy wypełniają ćwiczenie prawie
natychmiast z pamięci, jeśli zachowujesz pamięć podręczną. Wszystkie obrazy, których nie ma w pamięci podręcznej, są
które prawdopodobnie są dostępne w pamięci podręcznej dysku. Jeśli nie, zostaną przetworzone w zwykły sposób.