Can I somehow transport a `Deferred` out form a callback? got this pattern: ```kotlin val co...

# coroutines

[reactormonk]

Can I somehow transport a Deferred out form a callback? got this pattern:

kotlin
        val contract = ActivityResultContracts.StartActivityForResult()
        suspendCoroutine { cont ->
            registerForActivityResult(contract, contract.createIntent(this, client.signInIntent)) {
              <createing a Deferred here>
          }
        }

Can I somehow pull the Deferred directly into the suspendCoroutine, or do I have to do all the plumbing manually?

[Sam]

Can you elaborate on what you're trying to do here?

[reactormonk]

Full code:

val client = GoogleSignIn.getClient(this, GoogleSignInOptions.DEFAULT_SIGN_IN)
        val contract = ActivityResultContracts.StartActivityForResult()
        suspendCoroutine { cont ->
            registerForActivityResult(contract, contract.createIntent(this, client.signInIntent)) {
                val account = GoogleSignIn.getSignedInAccountFromIntent(it.data)
                val def = account.asDeferred()
            }
        }

The account is a Task, which I can convert to a Deferred to avoid the plumbing from Task to coroutines, but since I also have the registerForActivityResult callback, I was wondering if I can reuse the plumbing.

[Sam]

Okay, I see, so in effect we have a callback inside a callback 👍

[reactormonk]

Yup. The inner callback is already in a coroutine, so I wondered if I can avoid plumbing ^^

[Sam]

A Task lets you register your own callbacks, so I think the best option would be to add a completion listener to the task that will resume the continuation. In other words, skip the asDeferred and just connect account directly to cont.

[reactormonk]

Also gotta collect cancellation and exceptions, right?

[Sam]

sure 👍 -- use suspendCancellableCoroutine in place of suspendCoroutine so you can hook up all those extra callbacks

[reactormonk]

suspendCoroutine { cont ->
            registerForActivityResult(contract, contract.createIntent(this, client.signInIntent)) { activityResult ->
                val account = GoogleSignIn.getSignedInAccountFromIntent(activityResult.data)
                account.addOnCanceledListener { cont.resumeWithException(CancellationException()) }
                account.addOnCompleteListener { cont.resume(it) }
                account.addOnFailureListener { cont.resumeWithException(it) }
            }
        }

[reactormonk]

Aye

[Sam]

I mentioned suspendCancellableCoroutine but I think that is mostly relevant if you want cancellation to flow the other way, i.e. have the Task be cancelled when you cancel the suspended coroutine

[Sam]

I think your code looks good 👍

[Joffrey]

@Sam I think it's still important to have. If the account task supports cancellation, it should be done with suspendCancellableCoroutine.

[reactormonk]

Yup, fixed it

[Albert Chang]

Isn't this enough?

val contract = ActivityResultContracts.StartActivityForResult()
return coroutineScope.async {
    val result = suspendCoroutine { cont ->
        registerForActivityResult(contract, contract.createIntent(this, client.signInIntent)) {
            cont.resume(it)
        }
    }
    GoogleSignIn.getSignedInAccountFromIntent(result.data).await()
}

[Joffrey]

why the coroutineScope.async here?

[Albert Chang]

Because the OP wants a Deffered.

[reactormonk]

Nah, not really. Implementation detail.

[Joffrey]

Given where the conversation went, I don't think deferred was a goal in itself

[reactormonk]

But yeah, await outside is nice. Thanks.

[Joffrey]

Awaiting outside would allow you to generalize the wrapping of registerForActivityResult into a suspend function. By the way, don't you need a launch call on the ActivityResultLauncher returned by registerForActivityResult?

[reactormonk]

Ah yea, too much Haskell, there you get a type error if you forgot that 😭