Is there a way to have a callback in Kotlin/Native...

# kotlin-native

[Prateek Grover]

Is there a way to have a callback in Kotlin/Native?

private suspend fun syncFromNewtork(url: String): Boolean = suspendCoroutine { continuation ->
    val knResponseCallback: KNSyncManagerResponseCallBack = freezeObject(KNSyncManagerResponseCallBack(continuation))

    knNetworkBridge.makePostRestRequest(url: url)
}

class KNSyncManagerResponseCallBack(private val continuation: Continuation<Boolean>): KNResponseCallback {
    override fun onSuccess(response: Any?) {
        continuation.resume(true)
    }

    override fun onError(errorResponse: Any?) {
        continuation.resume(false)
    }
}

[Prateek Grover]

In this case, the KN side will call iOS side via network bridge and iOS side will make the actual network call on a different thread. It will then give a callback on a diff thread and KN has to handle it. Continuation has to be mutable and at the same time accessible between threads.

How do I handle this? Is this a good practice? Will I have to use AtomicRefs here?

[Kris Wong]

you'll either need atmoics or you will need to transfer ownership of the object between threads

[basher]

If I understand correctly, coroutineworker has a helper for this scenario: https://github.com/Autodesk/coroutineworker/blob/master/src/commonMain/kotlin/com/autodesk/coroutineworker/Utils.kt

[basher]

Can see the implementation here: https://github.com/Autodesk/coroutineworker/blob/master/src/nativeMain/kotlin/com/autodesk/coroutineworker/CoroutineUtils.kt#L15

[Prateek Grover]

Thanks Ben and Kris. Tried it with atomics itself. Makes it a bit dirty but I do not think there is any other way.

[basher]

tl;dr to avoid freezing the continuation, you wait and delay in the current thread/coroutine for the result to be posted from your bg thread into an atomic var

[Prateek Grover]

I am actually calling the ios swift function from the coroutine. waiting the coroutine would mean trying to make the swift function synchronous (network call) and would require me to do some semaphore or other synchronization construct.

Also, that implementation wouldnt be compatible with Android.

[Prateek Grover]

I mean it would be compatible but Android does not have that problem but still it will have to do something like iOS which is inefficient. Ami I rright?

[basher]

In the library on android, the implementation is different and avoids doing all this because it's not needed

[Prateek Grover]

ohh ok..will have a look at it

[basher]

It's not synchronous because the delay suspends

[basher]

It's the best that can be done for this scenario without the improved support for coroutines on native, which is coming in a future coroutines release

[Prateek Grover]

Got it. Thanks

[Thomas]

tl;dr to avoid freezing the continuation, you wait and delay in the current thread/coroutine for the result to be posted from your bg thread into an atomic var

Hi @basher, thanks for the solution, it really helped me! Do you know if this is still the best way to prevent freezing because of all the changes in native-mt?

[basher]

I believe that in native-mt, you don't have to take the same precautions around freezing coroutine internals. I haven't spent much time with native-mt yet, but I expect you could then switch to whatever the idiomatic method is in coroutines generally

[Thomas]

Yes you’re right! I just tried suspendCancellableCoroutine with native-mt and the continuation appears to already be frozen (at least in my testing code)