Is there any kind of mutex available that i can use in drawWithCache ?

I believe people can better help you if you show a code sample of what you want to achieve and what currently is not working for you.

Sure. I am trying to save a composable to a bitmap. Basically this approach: https://github.com/android/snippets/blob/56de2a4893da28c4c312783d893be8ef0eed6a81/[…]m/example/compose/snippets/graphics/AdvancedGraphicsSnippets.kt

I recently saw this post by @Rebecca Franks. Does it help maybe?

yes, i am using that approach. the problem is, that approach has a problem

Hm, maybe Rebecca has an idea?

and that will crash

Why do you use

<http://Dispatcher.IO|Dispatcher.IO>

?

its in the google sample. it can be heavy operation

I don’t see a Dispatcher mentioned in the example here 👀

it is in the original link i provided. It is compose team sample 😛

Hm, yeah, we need Rebecca who is the author of this code, I guess 😅

i can solve the problem keeping a Picture object per render. Which may be expensive also 😛

Have you tried the simple example from the website?

Again, the google sample as it is has this bug. I did no try rebeka approach, which i believe is similar. let me check

I ended up doing something like this:

private val pictureMutex = Mutex()
private val picture = Picture()

fun record(
        scope: ContentDrawScope,
        width: Int,
        height: Int
    ) {
        val locked = pictureMutex.tryLock()

        if (locked) {
            try {
                with(scope) {
                    val canvas = Canvas(picture.beginRecording(width, height))
                    draw(scope, scope.layoutDirection, canvas, scope.size) {
                        this@with.drawContent()
                    }
                    picture.endRecording()
                    drawIntoCanvas { drawCanvas ->
                        drawCanvas.nativeCanvas.drawPicture(picture)
                    }
                }
            } finally {
                pictureMutex.unlock()
            }
        } else {
            scope.drawContent()
        }
    }

    fun capture() {
        scope.launch {
            try {
                val bitmap = withContext(<http://Dispatchers.IO|Dispatchers.IO>) {
                    pictureMutex.withLock {
                        createBitmapFromPicture(picture)
                    }
                }
            }
        }
    }

It will suspend while trying to create the bitmap until the recording is finished. If it is attempting to record while saving is happening, it will skip recording. I think it is a better solution, since it does not mess with the drawing phase. Feedback from @Rebecca Franks is needed!

@myanmarking FYI, when you use ````` (three backticks) you can properly format a block of code

Thanks folks for the feedback, this doesn't sound great I agree. (cc @Nader Jawad too for context as he is also looking into improving the solution to use bitmaps with hardware acceleration across all versions of Android). Will revert back when we have an official solution here thank you color

You can probably get away with removing the coroutine usage here to avoid concurrency concerns.

That why there is a mutex

It is reasonable to render content into an offscreen bitmap as part of a typical render pass. The Android graphics pipeline does this internally for various use cases when content is promoted to a layer. While we should persist these bitmaps/layers across frames, doing a 1 off render if not prohibitive if done sparingly.

The usage of io dispatcher is in google examples, not mine. I just caught the problem here :)

@Rebecca Franks do you think we can update these samples here 🙂

I think the mutex solution is reasonable. It wont suspend when drawing. It will just do draw pass without capturing anything

@Nader Jawad thanks - yup will do!