Is it somehow possible to await a continuation?

You can convert it to a deferred. But what’s your use case? Suspended functions operate sequentially unless otherwise specified

You could

async { cont.resume() }

I suppose, but it doesn't return a value, so you probably want to use

launch

&

join

. Seems like an XY problem though.

How can I convert it to a deferred @Allan Wang?

I think you might have terms mixed up here -- a continuation doesn't have a strict sense of completion, that's all tied to

Job

, which you can already

join

on. A better model for your case might be to use an

actor

for each code, so that all permission requests are automatically processed sequentially. Then you don't have to wait for anything.

Why would that be better?

suspendCancellableCoroutine

gives me a continuation and that's exactly what I need

@Paul Woitaschek For your use-case a

CompletableDeferred

whould be a much better fit. Use and store them instead of continuations, and you'll have no problem waiting for the same one multiple times.

@elizarov How would that look like? In the end the signature would need to look like this:

suspend fun request(permission: String): PermissionResult

So I need to store what kind of permission I was requesting, right?

Something like this:

suspend fun request(permission: String) = 
    mapPermissionToDeferred.getOrPut(permsision) { 
        requestPermission(permission)
    }.await()

And how does that solve the problem of concurrent requests?

hmm, looking into the android permission request model, I think

CompletableDeferred

is on the right track. Basically, since (If I'm interpreting your words correctly) you can only call

requestPermissions

one at a time, you can store the

requestCode

& a

CompletableDeferred

, then in your

suspend fun request

, if it's non-null,

await

it first. Then set the request code, a new

CompletableDeferred

, and call

requestPermission

. Then await your new deferred. You might need to use a

Mutex

here to ensure it's concurrently-safe, or box the requests in a data object and use

actor

to automatically sequential-ize* it. In

onRequestPermissionsResult

, you can check the code against the field, then complete the deferred. No Map needed.

Assyming that you only call

suspend fun request

from your main thread (you can wrap its body into

withContext(Dispatchers.Main) { ... }

to be sure, you'll never get two concurrent requests to the same permission, since the first one will get stored in the map via

getOrPut

But I don't want to store the permission result permanently because the result might change

there's also that option

to be sure, you'll never get two concurrent requests to the same permission

No, I must be sure to never get two concurrent requests ever, unregarding of the permission type

@Paul Woitaschek In this case it would be prudent to create a global actor that makes request. It would check incoming requsts, complete, then, then remove deferred from the map, go to the next request:

And what is the benefit with the

CompletableDeferred

?

suspend fun requestPermission: (permission: String, result: CompletableDeferred<PermissionResult>): PermissionResult = permission.send(permission to PermissionResult)

where

permissionActor = actor<Pair<String, PermissionResult>> {
    for ((permission, result) in channel) {
        val permission = getIt(...)
        result.complete(permission)
        mapPermissionToDeferred.remove(permission)
        // ^^ this way future requests will request it again
    }
}

My idea translates roughly like this: https://gist.github.com/kenzierocks/bc80dead52b71448477ea2ff21cf0ff4 you may not need the mutex depending on the threading model

And calling

actor.send

waits till the actor is empty? How do I get a result from it?

send a

CompletableDeferred

. have the actor complete it

@Paul Woitaschek Did you try Splitties permissions? It should handle the situation where you request multiple permissions concurrently by spawning another Activity. Here's the link: https://github.com/LouisCAD/Splitties/tree/master/modules/permissions