Recycle hardware bitmaps to release graphics memory sooner

Author: p-lr

Readme.md

@@ -3,6 +3,8 @@
 [![](https://img.shields.io/badge/ComposeBOM-2025.02.00-brightgreen)](https://developer.android.com/jetpack/compose/bom/bom)
 
 🎉 News:
+- Memory footprint has been dramatically reduced on Android 10 and above, by leveraging [Hardware Bitmaps](https://bumptech.github.io/glide/doc/hardwarebitmaps.html).
+  Software rendering is however still required when there's more than one layer.
 - MapCompose Multiplatform is officially released: https://github.com/p-lr/MapComposeMP \
   Works on iOS, MacOS, Windows, Linux, and Android.
 - New path dash pattern api: ability to define a sequence made of dash, dot, and gap.
@@ -73,7 +75,7 @@ There's an example in the demo app.
 
 Add this to your module's build.gradle
 ```groovy
-implementation 'ovh.plrapps:mapcompose:2.15.0'
+implementation 'ovh.plrapps:mapcompose:2.16.0'
 ```
 
 Starting with v.2.4.1, the library is using the 

mapcompose/src/main/java/ovh/plrapps/mapcompose/ui/state/TileCanvasState.kt

@@ -60,6 +60,8 @@ internal class TileCanvasState(
     private val lastVisible: VisibleTiles?
         get() = visibleStateFlow.value?.visibleTiles
 
+    private val recycleChannel = Channel<Tile>(Channel.UNLIMITED)
+
     /**
      * So long as this debounced channel is offered a message, the lambda isn't called.
      */
@@ -117,6 +119,14 @@ internal class TileCanvasState(
         scope.launch {
             consumeTiles(tilesOutput)
         }
+
+        scope.launch(Dispatchers.Main) {
+            for (t in recycleChannel) {
+                val b = t.bitmap
+                t.bitmap = null
+                b?.recycle()
+            }
+        }
     }
 
     fun setLayers(layers: List<Layer>) {
@@ -409,12 +419,20 @@ internal class TileCanvasState(
     }
 
     /**
-     * After a [Tile] is no longer visible, recycle its Bitmap and Paint if possible, for later use.
+     * After a [Tile] is no longer visible, depending on the bitmap mutability:
+     * - If the Bitmap is mutable, put it into the pool for later use.
+     * - If the bitmap isn't mutable, we don't use bitmap pooling. That means the associated graphic
+     * memory can be reclaimed asap.
+     * The Compose framework draws tiles on the main thread and checks whether or not [Tile.bitmap]
+     * is null. So, prior to calling recycle() we set [Tile.bitmap] to null on the main thread. This
+     * is done inside the coroutine which consumes [recycleChannel].
      */
     private fun Tile.recycle() {
         val b = bitmap ?: return
         if (b.isMutable) {
             bitmapPool.put(b)
+        } else {
+            recycleChannel.trySend(this)
         }
         alpha = 0f
     }