Cómo administrar la memoria del mapa de bits

Nota: En la mayoría de los casos, te recomendamos que uses la biblioteca de Glide para obtener, decodificar y mostrar mapas de bits en tu app. Glide facilita el manejo de estas y otras tareas relacionadas con el trabajo con mapas de bits y otras imágenes en Android. Para obtener información sobre el uso y la descarga de Glide, visita el repositorio de Glide en GitHub.

Además de los pasos descritos en Cómo almacenar mapas de bits en la caché, hay acciones específicas que puedes llevar a cabo para facilitar la recolección de elementos no utilizados y la reutilización de mapas de bits. La estrategia recomendada depende de las versiones de Android a las que apuntes. La aplicación de ejemplo BitmapFun incluida con esta clase te muestra cómo diseñar tu app para que funcione de manera eficaz en diferentes versiones de Android.

A fin de preparar el escenario para esta lección, a continuación se muestra cómo evolucionó la administración de la memoria de mapa de bits de Android:

  • En Android 2.2 (API nivel 8) o versiones anteriores, cuando se produce una recolección de elementos no utilizados, se detienen los subprocesos de tu app. Esto provoca un retraso que puede disminuir el rendimiento. Android 2.3 agrega recolección simultánea de elementos no utilizados, lo que significa que la memoria se recupera poco después de que se deja de hacer referencia a un mapa de bits.
  • En Android 2.3.3 (API nivel 10) y versiones anteriores, los datos de píxeles de copia de seguridad de un mapa de bits se almacenan en la memoria nativa. Están separados del mapa de bits, que se almacena en la pila de Dalvik. Los datos de píxeles de la memoria nativa no se liberan de manera predecible, lo que puede causar que una aplicación exceda brevemente sus límites de memoria y se bloquee. Desde Android 3.0 (API nivel 11) hasta Android 7.1 (API nivel 25), los datos de píxeles se almacenan en la pila de Dalvik junto con el mapa de bits asociado. En Android 8.0 (API nivel 26) y versiones posteriores, los datos de píxeles del mapa de bits se almacenan en la pila nativa.

En las siguientes secciones, se describe cómo optimizar la administración de memoria de mapa de bits para diferentes versiones de Android.

Cómo administrar la memoria en Android 2.3.3 y versiones anteriores

En Android 2.3.3 (API nivel 10) y versiones anteriores, se recomienda el uso de recycle(). Si se muestran grandes cantidades de datos de mapas de bits en tu app, es probable que se generen errores de OutOfMemoryError. El método recycle() permite que una app reclame la memoria lo antes posible.

Precaución: Para usar recycle(), debes estar seguro de que el mapa de bits ya no se usa. Si llamas a recycle() y luego tratas de generar el mapa de bits, obtendrás este error: "Canvas: trying to use a recycled bitmap".

En el siguiente fragmento de código, se muestra un ejemplo de una llamada a recycle(). Utiliza el recuento de referencias (en las variables mDisplayRefCount y mCacheRefCount) para rastrear si un mapa de bits se está mostrando actualmente o en la memoria caché. El código recicla el mapa de bits cuando se cumplen estas condiciones:

  • El recuento de referencias para mDisplayRefCount y mCacheRefCount es 0.
  • El mapa de bits no es null y aún no se ha reciclado.

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

Cómo administrar la memoria en Android 3.0 y versiones posteriores

Android 3.0 (API nivel 11) presenta el campo BitmapFactory.Options.inBitmap. Si se define esta opción, los métodos de decodificación que toman el objeto Options intentarán reutilizar un mapa de bits existente cuando se cargue contenido. Esto significa que se reutiliza la memoria del mapa de bits, lo que mejora el rendimiento y quita la asignación y la anulación de asignación de memoria. Sin embargo, existen ciertas restricciones sobre cómo se puede usar inBitmap. En particular, en las versiones anteriores a Android 4.4 (API nivel 19), solo se admiten mapas de bits de igual tamaño. Para obtener más información, consulta la documentación de inBitmap.

Guarda un mapa de bits para uso posterior

En el siguiente fragmento, se demuestra cómo se almacena un mapa de bits existente para su posible uso posterior en la app de muestra. Cuando se ejecuta una app en Android 3.0 o versiones posteriores y se quita un mapa de bits de LruCache, se coloca una referencia al mapa de bits en un HashSet para su posible reutilización en otro momento con 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()));
                }
            }
        }
    ....
    }
    

Usa un mapa de bits existente

En la app en ejecución, los métodos de decodificador verifican si hay un mapa de bits existente que puedan usar. Por ejemplo:

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

En el siguiente fragmento, se muestra el método addInBitmapOptions(), que se llama en el fragmento anterior. Busca un mapa de bits existente para establecer como valor de inBitmap. Ten en cuenta que este método solo establece un valor para inBitmap si encuentra una coincidencia adecuada (tu código nunca debe suponer que se encontrará una coincidencia):

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

Por último, este método determina si un mapa de bits candidato satisface los criterios de tamaño que se usarán en 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;
    }