Coil preloading does not work if contentScale is specified

[Mortalite]

Good afternoon, in our application user can set a wallpaper from the gallery, take a photo or choose from the available ones. When selecting from the gallery, the image is copied to the application folder (getFilesDir/dir) and later will be used to display after logging into the account, this approach has a disadvantage - if the user sets an image of large size (4000x6000) and weighing several megabytes, the image will be displayed after a second, which is very long.

I tried to preload the image, but I encountered that due to specifying ContentScale.Crop in AsyncImage, the image keeps loading after a second instead of immediately from memory and after displaying with ContentScale.Crop type, the memory cache increases.

If you use AsyncImage with ContentScale by default, the image will be shown instantly from memory and memory cache will not increase.

How can the problem be solved?

[MagenL]

Hi,
just a question, do you need the image at full quality?
I would try to down scale it before caching it

here is a basic implementation to compress bitmaps -

> fun Bitmap.compressBitmap(maxKB: Int = 10, minQualitySize: Int = 5): Bitmap? {
>     val bitmap: Bitmap
>     var quality = 100
>     var byteArray: ByteArray
>     do {
>         ByteArrayOutputStream().use { stream ->
>             this.compress(Bitmap.CompressFormat.JPEG, quality, stream)
>             byteArray = stream.toByteArray()
>             Log.d(
>                 "compressBitmap",
>                 "optimizing.. current size = ${byteArray.size / 1024} quality = $quality"
>             )
>             quality -= (quality * 0.05f).roundToInt()
>         }
>     } while ((byteArray.size / 1024) > maxKB && quality > minQualitySize)
>     bitmap = BitmapFactory.decodeByteArray(byteArray, 0, byteArray.size)
>     this.recycle()
>     Log.d("compressBitmap", "byteArraySize = ${byteArray.size / 1024}KB")
>     return bitmap
> }

[Mortalite]

Hello, I am saving an image without compression. When I experimented with compression, it seemed to me that there was a long wait of 3-10 seconds instead of instantly setting the image.

[colinrtwhite]

If you enable debug logging it will log why the image isn't served from the cache. You likely need to set Scale.FILL on your image request to match the ContentScale.Crop. Without it, the image will be smaller than needed to fill the AsyncImage.

[Mortalite]

I got it (debug log: Successful (MEMORY-CACHE)), portrait and landscape images (height is greater than width and vice versa) are preloaded with this code:

Preload:
context.imageLoader.enqueue(
ImageRequest.Builder(LocalContext.current))
.data(content.uri)
.scale(Scale.FILL)
.size(getSize(context))
.build())

fun getSize(context: Context): Size {
if (SDK_INT >= P) {
val windowManager = context.getSystemService(Context.WINDOW_SERVICE) as WindowManager
val bounds = windowManager.currentWindowMetrics.bounds
return Size(bounds.width(), bounds.height()
} else { ... }}

Activity (using edge-to-edge):
AsyncImage(
model = ImageRequest.Builder(LocalContext.current))
.data(state.content.uri)
.scale(Scale.FILL)
.build(),
contentScale = ContentScale.Crop)

In the source code, the loading (enqueue) is done with Main.immediate, why not IO?