Uwaga: w większości przypadków zalecamy korzystanie z biblioteki Glide do pobierania, dekodowania i wyświetlania map bitowych w aplikacji. Glide eliminuje większość złożoności obsługi tych i innych zadań związanych z pracą z mapami bitowymi i innymi obrazami na Androidzie. Informacje o używaniu i pobieraniu Glide znajdziesz w repozytorium Glide na GitHubie.
Oprócz czynności opisanych w sekcji Zapisywanie map bitowych w pamięci podręcznej możesz wykonać określone czynności, aby ułatwić odśmiecanie pamięci i ponowne używanie map bitowych. Zalecana strategia zależy od wersji Androida, na którą kierujesz reklamy. Przykładowa aplikacja BitmapFun uwzględniona w tej klasie pokazuje, jak zaprojektować aplikację tak, aby działała efektywnie w różnych wersjach Androida.
Na potrzeby tej lekcji ukaże się następujące ewolucje zarządzania pamięcią bitmapową w Androidzie:
- Na Androidzie 2.2 (poziom interfejsu API 8) i starszych w przypadku odśmiecania wątków wątki aplikacji są zatrzymywane. Powoduje to opóźnienie, które może obniżyć wydajność. Android 2.3 dodaje funkcję równoczesnego odśmiecania, co oznacza, że pamięć jest odzyskiwana wkrótce po wycofaniu odniesienia do bitmapy.
- Na urządzeniach z Androidem w wersji 2.3.3 (poziom interfejsu API 10) i starszych dane piksela źródłowego dla mapy bitowej są przechowywane w pamięci natywnej. Jest niezależna od samej bitmapy, która jest przechowywana na stercie Dalvik. Dane pikseli w pamięci natywnej nie są udostępniane w przewidywalny sposób, co może powodować krótkotrwałe przekroczenie limitów pamięci i awarię aplikacji. Od Androida od 3.0 (poziom interfejsu API 11) do 7.1 (poziom interfejsu API 25) dane pikseli są przechowywane na stercie Dalvik wraz z powiązaną bitmapą. W Androidzie 8.0 (poziom interfejsu API 26) i nowszych dane pikseli bitmapowych są przechowywane na stercie natywnej.
W sekcjach poniżej dowiesz się, jak zoptymalizować zarządzanie pamięcią bitmap w przypadku różnych wersji Androida.
Zarządzanie pamięcią na Androidzie 2.3.3 i starszych wersjach
W Androidzie 2.3.3 (poziom interfejsu API 10) i starszych zalecamy użycie recycle(). Jeśli wyświetlasz w aplikacji duże ilości danych bitmapowych, mogą wystąpić błędy OutOfMemoryError. Metoda recycle() umożliwia aplikacji jak najszybsze odzyskanie pamięci.
Uwaga: recycle() należy używać tylko wtedy, gdy masz pewność, że mapa bitowa nie jest już używana. Jeśli wywołasz recycle(), a później spróbujesz narysować bitmapę, pojawi się błąd: "Canvas: trying to use a recycled bitmap".
W tym fragmencie kodu znajdziesz przykład wywołania recycle(). Wykorzystuje zliczanie odwołań (w zmiennych mDisplayRefCount i mCacheRefCount), aby śledzić, czy bitmapa jest obecnie wyświetlana czy w pamięci podręcznej. Kod odświeża bitmapę, gdy są spełnione te warunki:
- Liczba plików referencyjnych w
mDisplayRefCountimCacheRefCountwynosi 0. - Bitmapa nie jest
nulli nie została jeszcze poddana recyklingowi.
Kotlin
private var cacheRefCount: Int = 0
private var displayRefCount: Int = 0
...
// Notify the drawable that the displayed state has changed.
// Keep a count to determine when the drawable is no longer displayed.
fun setIsDisplayed(isDisplayed: Boolean) {
synchronized(this) {
if (isDisplayed) {
displayRefCount++
hasBeenDisplayed = true
} else {
displayRefCount--
}
}
// Check to see if recycle() can be called.
checkState()
}
// Notify the drawable that the cache state has changed.
// Keep a count to determine when the drawable is no longer being cached.
fun setIsCached(isCached: Boolean) {
synchronized(this) {
if (isCached) {
cacheRefCount++
} else {
cacheRefCount--
}
}
// Check to see if recycle() can be called.
checkState()
}
@Synchronized
private fun checkState() {
// If the drawable cache and display ref counts = 0, and this drawable
// has been displayed, then recycle.
if (cacheRefCount <= 0
&& displayRefCount <= 0
&& hasBeenDisplayed
&& hasValidBitmap()
) {
getBitmap()?.recycle()
}
}
@Synchronized
private fun hasValidBitmap(): Boolean =
getBitmap()?.run {
!isRecycled
} ?: false
Java
private int cacheRefCount = 0;
private int displayRefCount = 0;
...
// Notify the drawable that the displayed state has changed.
// Keep a count to determine when the drawable is no longer displayed.
public void setIsDisplayed(boolean isDisplayed) {
synchronized (this) {
if (isDisplayed) {
displayRefCount++;
hasBeenDisplayed = true;
} else {
displayRefCount--;
}
}
// Check to see if recycle() can be called.
checkState();
}
// Notify the drawable that the cache state has changed.
// Keep a count to determine when the drawable is no longer being cached.
public void setIsCached(boolean isCached) {
synchronized (this) {
if (isCached) {
cacheRefCount++;
} else {
cacheRefCount--;
}
}
// Check to see if recycle() can be called.
checkState();
}
private synchronized void checkState() {
// If the drawable cache and display ref counts = 0, and this drawable
// has been displayed, then recycle.
if (cacheRefCount <= 0 && displayRefCount <= 0 && hasBeenDisplayed
&& hasValidBitmap()) {
getBitmap().recycle();
}
}
private synchronized boolean hasValidBitmap() {
Bitmap bitmap = getBitmap();
return bitmap != null && !bitmap.isRecycled();
}
Zarządzanie pamięcią w Androidzie 3.0 lub nowszym
Android 3.0 (poziom interfejsu API 11) wprowadza pole BitmapFactory.Options.inBitmap. Jeśli ta opcja jest ustawiona, metody dekodowania, które przejmują obiekt Options, będą próbowały ponownie użyć istniejącej bitmapy podczas wczytywania treści. Oznacza to, że ponownie jest wykorzystywana pamięć bitmapy, co zwiększa wydajność, a także usuwa przydział pamięci i jego delokację. Istnieją jednak pewne ograniczenia dotyczące sposobów korzystania z elementu inBitmap. W szczególności w przypadku Androida w wersjach starszych niż 4.4 (poziom interfejsu API 19) obsługiwane są tylko mapy bitowe o równym rozmiarze. Szczegółowe informacje znajdziesz w dokumentacji inBitmap.
Zapisywanie bitmapy do późniejszego użycia
Ten fragment kodu pokazuje, jak istniejąca bitmapa jest przechowywana do późniejszego użycia w przykładowej aplikacji. Jeśli aplikacja działa na Androidzie w wersji 3.0 lub nowszej i zostanie usunięta z mapy LruCache, łagodne odniesienie do bitmapy jest umieszczane w pliku HashSet, które można później wykorzystać w inBitmap:
Kotlin
var reusableBitmaps: MutableSet<SoftReference<Bitmap>>? = null
private lateinit var memoryCache: LruCache<String, BitmapDrawable>
// If you're running on Honeycomb or newer, create a
// synchronized HashSet of references to reusable bitmaps.
if (Utils.hasHoneycomb()) {
reusableBitmaps = Collections.synchronizedSet(HashSet<SoftReference<Bitmap>>())
}
memoryCache = object : LruCache<String, BitmapDrawable>(cacheParams.memCacheSize) {
// Notify the removed entry that is no longer being cached.
override fun entryRemoved(
evicted: Boolean,
key: String,
oldValue: BitmapDrawable,
newValue: BitmapDrawable
) {
if (oldValue is RecyclingBitmapDrawable) {
// The removed entry is a recycling drawable, so notify it
// that it has been removed from the memory cache.
oldValue.setIsCached(false)
} else {
// The removed entry is a standard BitmapDrawable.
if (Utils.hasHoneycomb()) {
// We're running on Honeycomb or later, so add the bitmap
// to a SoftReference set for possible use with inBitmap later.
reusableBitmaps?.add(SoftReference(oldValue.bitmap))
}
}
}
}
Java
Set<SoftReference<Bitmap>> reusableBitmaps;
private LruCache<String, BitmapDrawable> memoryCache;
// If you're running on Honeycomb or newer, create a
// synchronized HashSet of references to reusable bitmaps.
if (Utils.hasHoneycomb()) {
reusableBitmaps =
Collections.synchronizedSet(new HashSet<SoftReference<Bitmap>>());
}
memoryCache = new LruCache<String, BitmapDrawable>(cacheParams.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)) {
// The removed entry is a recycling drawable, so notify it
// that it has been removed from the memory cache.
((RecyclingBitmapDrawable) oldValue).setIsCached(false);
} else {
// The removed entry is a standard BitmapDrawable.
if (Utils.hasHoneycomb()) {
// We're running on Honeycomb or later, so add the bitmap
// to a SoftReference set for possible use with inBitmap later.
reusableBitmaps.add
(new SoftReference<Bitmap>(oldValue.getBitmap()));
}
}
}
....
}
Użyj istniejącej mapy bitowej
W działającej aplikacji metody dekodera sprawdzają, czy istnieje już bitmapa, której można użyć. Na przykład:
Kotlin
fun decodeSampledBitmapFromFile(
filename: String,
reqWidth: Int,
reqHeight: Int,
cache: ImageCache
): Bitmap {
val options: BitmapFactory.Options = BitmapFactory.Options()
...
BitmapFactory.decodeFile(filename, options)
...
// If we're running on Honeycomb or newer, try to use inBitmap.
if (Utils.hasHoneycomb()) {
addInBitmapOptions(options, cache)
}
...
return BitmapFactory.decodeFile(filename, options)
}
Java
public static Bitmap decodeSampledBitmapFromFile(String filename,
int reqWidth, int reqHeight, ImageCache cache) {
final BitmapFactory.Options options = new BitmapFactory.Options();
...
BitmapFactory.decodeFile(filename, options);
...
// If we're running on Honeycomb or newer, try to use inBitmap.
if (Utils.hasHoneycomb()) {
addInBitmapOptions(options, cache);
}
...
return BitmapFactory.decodeFile(filename, options);
}
Następny fragment kodu zawiera metodę addInBitmapOptions() wywoływaną w powyższym fragmencie. Szuka istniejącej bitmapy, którą można ustawić jako wartość parametru inBitmap. Pamiętaj, że ta metoda ustawia wartość parametru inBitmap tylko wtedy, gdy znajdzie odpowiednie dopasowanie (Twój kod nie powinien nigdy zakładać, że dopasowanie zostanie znalezione):
Kotlin
private fun addInBitmapOptions(options: BitmapFactory.Options, cache: ImageCache?) {
// inBitmap only works with mutable bitmaps, so force the decoder to
// return mutable bitmaps.
options.inMutable = true
// Try to find a bitmap to use for inBitmap.
cache?.getBitmapFromReusableSet(options)?.also { inBitmap ->
// If a suitable bitmap has been found, set it as the value of
// inBitmap.
options.inBitmap = inBitmap
}
}
// This method iterates through the reusable bitmaps, looking for one
// to use for inBitmap:
fun getBitmapFromReusableSet(options: BitmapFactory.Options): Bitmap? {
mReusableBitmaps?.takeIf { it.isNotEmpty() }?.let { reusableBitmaps ->
synchronized(reusableBitmaps) {
val iterator: MutableIterator<SoftReference<Bitmap>> = reusableBitmaps.iterator()
while (iterator.hasNext()) {
iterator.next().get()?.let { item ->
if (item.isMutable) {
// Check to see it the item can be used for inBitmap.
if (canUseForInBitmap(item, options)) {
// Remove from reusable set so it can't be used again.
iterator.remove()
return item
}
} else {
// Remove from the set if the reference has been cleared.
iterator.remove()
}
}
}
}
}
return null
}
Java
private static void addInBitmapOptions(BitmapFactory.Options options,
ImageCache cache) {
// inBitmap only works with mutable bitmaps, so force the decoder to
// return mutable bitmaps.
options.inMutable = true;
if (cache != null) {
// Try to find a bitmap to use for inBitmap.
Bitmap inBitmap = cache.getBitmapFromReusableSet(options);
if (inBitmap != null) {
// If a suitable bitmap has been found, set it as the value of
// inBitmap.
options.inBitmap = inBitmap;
}
}
}
// This method iterates through the reusable bitmaps, looking for one
// to use for inBitmap:
protected Bitmap getBitmapFromReusableSet(BitmapFactory.Options options) {
Bitmap bitmap = null;
if (reusableBitmaps != null && !reusableBitmaps.isEmpty()) {
synchronized (reusableBitmaps) {
final Iterator<SoftReference<Bitmap>> iterator
= reusableBitmaps.iterator();
Bitmap item;
while (iterator.hasNext()) {
item = iterator.next().get();
if (null != item && item.isMutable()) {
// Check to see it the item can be used for inBitmap.
if (canUseForInBitmap(item, options)) {
bitmap = item;
// Remove from reusable set so it can't be used again.
iterator.remove();
break;
}
} else {
// Remove from the set if the reference has been cleared.
iterator.remove();
}
}
}
}
return bitmap;
}
Na koniec ta metoda określa, czy kandydująca mapa bitowa spełnia kryteria dotyczące rozmiaru, które mają być używane w przypadku elementu inBitmap:
Kotlin
private fun canUseForInBitmap(candidate: Bitmap, targetOptions: BitmapFactory.Options): Boolean {
return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
// From Android 4.4 (KitKat) onward we can re-use if the byte size of
// the new bitmap is smaller than the reusable bitmap candidate
// allocation byte count.
val width: Int = targetOptions.outWidth / targetOptions.inSampleSize
val height: Int = targetOptions.outHeight / targetOptions.inSampleSize
val byteCount: Int = width * height * getBytesPerPixel(candidate.config)
byteCount <= candidate.allocationByteCount
} else {
// On earlier versions, the dimensions must match exactly and the inSampleSize must be 1
candidate.width == targetOptions.outWidth
&& candidate.height == targetOptions.outHeight
&& targetOptions.inSampleSize == 1
}
}
/**
* A helper function to return the byte usage per pixel of a bitmap based on its configuration.
*/
private fun getBytesPerPixel(config: Bitmap.Config): Int {
return when (config) {
Bitmap.Config.ARGB_8888 -> 4
Bitmap.Config.RGB_565, Bitmap.Config.ARGB_4444 -> 2
Bitmap.Config.ALPHA_8 -> 1
else -> 1
}
}
Java
static boolean canUseForInBitmap(
Bitmap candidate, BitmapFactory.Options targetOptions) {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
// From Android 4.4 (KitKat) onward we can re-use if the byte size of
// the new bitmap is smaller than the reusable bitmap candidate
// allocation byte count.
int width = targetOptions.outWidth / targetOptions.inSampleSize;
int height = targetOptions.outHeight / targetOptions.inSampleSize;
int byteCount = width * height * getBytesPerPixel(candidate.getConfig());
return byteCount <= candidate.getAllocationByteCount();
}
// On earlier versions, the dimensions must match exactly and the inSampleSize must be 1
return candidate.getWidth() == targetOptions.outWidth
&& candidate.getHeight() == targetOptions.outHeight
&& targetOptions.inSampleSize == 1;
}
/**
* A helper function to return the byte usage per pixel of a bitmap based on its configuration.
*/
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;
}