Bit Eşlem Belleğini Yönetme

Not: Çoğu durumda, Glide kitaplığını getirir, kodu çözer ve uygulamanızda bit eşlemler görüntüleme. Özetlerin çoğunu kaydırarak ve bunları ele almanın karmaşıklığını başka görevler de vardır. Glide'ı kullanma ve indirme hakkında bilgi edinmek için şu sayfayı ziyaret edin: GitHub'da Glide deposu.

Bit eşlemelerini önbelleğe alma bölümünde açıklanan adımlara ek olarak, atık toplamayı kolaylaştırmak için yapabileceğiniz belirli şeyler var. ve bit eşlemi yeniden kullanabilirsiniz. Önerilen strateji, hangi sürümlerin Android'de hangi özellikleri arayın? BitmapFun örnek uygulaması Bu derste, uygulamanızı farklı cihazlarda verimli Android'in farklı sürümleri.

Bu derse zemin hazırlarken Android'in veri yönetimi sistemlerinin bit eşlem belleği gelişti:

• Android 2.2 (API düzeyi 8) ve önceki sürümlerde, çöp olduğunda veri toplama işlemi gerçekleşirse uygulamanızın ileti dizileri durdurulur. Bu da ekibinizin performansı düşürebilir. Android 2.3, çöpleri eşzamanlı olarak toplama özelliğini ekler. Bu da bit eşlemin referans alınmasının ardından kısa bir süre sonra bellek geri alınır.
• Android 2.3.3 (API düzeyi 10) ve önceki sürümlerde, yerel bellekte depolanır. Bit eşlemin kendisinden ayrıdır. depoladığı bir kopyadır. Yerel bellekteki piksel verileri: tahmin edilebilir bir şekilde yayınlanmaması, dolayısıyla da bir uygulamaya ve çökmesine neden oluyor. Android 3.0'dan (API düzeyi 11) 7.1 (API düzeyi 25) sürümüne kadar, piksel verileri Dalvik yığını, ilişkili bit eşlem ile birlikte gösterilir. Android 8.0 (API düzeyi 26) sürümünde, ve daha yüksek olursa bit eşlem piksel verileri yerel yığında depolanır.

Aşağıdaki bölümlerde bit eşlem belleğinin nasıl optimize edileceği açıklanmaktadır farklı Android sürümleri için yönetim.

Android 2.3.3 ve Önceki Sürümlerde Belleği Yönetme

Android 2.3.3 (API düzeyi 10) ve önceki sürümlerde recycle(). önerilir. Uygulamanızda büyük miktarda bit eşlem verisi görüntülüyorsanız proje zaman çizelgenizde OutOfMemoryError hata. İlgili içeriği oluşturmak için kullanılan recycle() yöntemi uygulamaya izin verir hafızayı mümkün olan en kısa sürede geri kazanmak gerekiyor.

Dikkat: recycle() öğesini yalnızca bit eşlem artık kullanılmıyor. recycle() adlı kişiyi ararsanız ve daha sonra bit eşlemi çizmeyi denerseniz şu hatayı alırsınız: "Canvas: trying to use a recycled bitmap".

Aşağıdaki kod snippet'i, recycle() Referans sayma yöntemini kullanır (mDisplayRefCount ve mCacheRefCount değişkenlerinde) veya önbellekte görüntülenip görüntülenmediği. İlgili içeriği oluşturmak için kullanılan kodu, şu koşullar karşılandığında bit eşlemi geri dönüştürür:

• Hem mDisplayRefCount hem de mDisplayRefCount için referans sayısı mCacheRefCount 0'dır.
• Bit eşlem null değil ve henüz geri dönüştürülmedi.

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();
}

Android 3.0 ve sonraki sürümlerde Belleği Yönetme

Android 3.0 (API düzeyi 11), BitmapFactory.Options.inBitmap. girin. Bu seçenek ayarlanırsa Options nesne , içerik yüklenirken mevcut bir bit eşlemi yeniden kullanmayı dener. Bunun anlamı şudur: Bu da bit eşlemin belleğinin yeniden kullanılmasını sağlayarak performansı artırır ve hem de bellek ayırma ve ayırma kaldırılıyor. Ancak, inBitmap kullanılabilir. Özellikle de Android'den önce 4.4 (API düzeyi 19) için yalnızca eşit boyutlu bit eşlemler desteklenir. Ayrıntılar için lütfen inBitmap belgeleri.

Daha sonra kullanmak için bit eşlem kaydetme

Aşağıdaki snippet, mevcut bir bit eşlemin olası her işlem için nasıl depolandığını gösterir sonradan örnek uygulamada kullanabilirsiniz. Bir uygulama Android 3.0 veya sonraki bir sürümde çalışırken ve LruCache öğesinden bir bit eşlem çıkarılır. bit eşlem için yumuşak bir referans yerleştirildiğinde daha sonra tekrar kullanılmak üzere HashSet içinde 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()));
            }
        }
    }
....
}

Mevcut bir bit eşlemi kullan

Çalışan uygulamada, kod çözücü yöntemleri, aynı sayfada mevcut bir bir bit eşlem var. Örnek:

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);
}

Sonraki snippet,addInBitmapOptions() üst kısımdır. Şu öğenin değeri olarak ayarlanacak mevcut bir bit eşlem arar: inBitmap Bu yöntemi yalnızca inBitmap için bir değer ayarlıyor uygun bir eşleşme bulursa (kodunuz hiçbir zaman bir eşleşme bulunacağını varsaymamalıdır):

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;
}

Son olarak, bu yöntem bir aday bit eşlemin ve kullanılacak boyut ölçütlerini karşılamalıdır. 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 = ceil((targetOptions.outWidth * 1.0f / targetOptions.inSampleSize).toDouble()).toInt()
        val height = ceil((targetOptions.outHeight * 1.0f / targetOptions.inSampleSize).toDouble()).toInt()
        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 = (int) Math.ceil(targetOptions.outWidth * 1.0f / targetOptions.inSampleSize);
        int height = (int) Math.ceil(targetOptions.outHeight * 1.0f / 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;
}