La funzione withTimeout fornisce IllegalStateException: non esiste un ciclo di eventi. Utilizzare runBlocking {…} per avviarne uno. nel client iOS multipiattaforma di Kotlin

Aggiornamento: funziona se eseguo prima una routine senza timeout e poi con Timeout. Ma se eseguo prima una routine con Timeout, allora mi dà un errore. lo stesso vale per Async.

Sto creando un'applicazione multipiattaforma demo kotlin in cui eseguo una chiamata API con ktor. Voglio avere una funzione di timeout configurabile su richiesta di Ktor, quindi sto usando withTimeout a livello di routine.

Ecco la mia chiamata di funzione con l'API di rete.

suspend fun <T> onNetworkWithTimeOut(
    url: String,
    timeoutInMillis: Long,
    block: suspend CoroutineScope.() -> Any): T {
    return withTimeout(timeoutInMillis) {
        withContext(dispatchers.io, block)
    } as T
}

suspend fun <T> onNetworkWithoutTimeOut(url: String, block: suspend CoroutineScope.() -> Any): T {
    return withContext(dispatchers.io, block) as T
}

Ecco la mia classe AppDispatcher per il modulo iOSMain.

@InternalCoroutinesApi
actual class AppDispatchersImpl : AppDispatchers {
@SharedImmutable
override val main: CoroutineDispatcher =
    NsQueueDispatcher(dispatch_get_main_queue())

@SharedImmutable
override val io: CoroutineDispatcher =
    NsQueueDispatcher(dispatch_get_main_queue())

internal class NsQueueDispatcher(
    @SharedImmutable private val dispatchQueue: dispatch_queue_t
) : CoroutineDispatcher() {
    override fun dispatch(context: CoroutineContext, block: Runnable) {
        NSRunLoop.mainRunLoop().performBlock {
            block.run()
        }
    }
}

}

quindi la funzione con il timeout mi dà il seguente errore nel client iOS.

kotlin.IllegalStateException: There is no event loop. Use runBlocking { ... } to start one.

Sto usando la versione 1.3.2-native-mt-1 del kotlin-coroutine-native. Ho creato un'applicazione demo di esempio al seguente URL. https://github.com/dudhatparesh/kotlin-multiplat-platform-example

Quindi, come menzionato nel commento sopra, ho avuto un problema simile ma ho scoperto che non stava rilevando la native-mtversione a causa delle dipendenze transitive in altre librerie. Aggiunto di seguito e si sta risolvendo ora.

        implementation('org.jetbrains.kotlinx:kotlinx-coroutines-core-native') 
        {
            version {
                strictly '1.3.3-native-mt'
            }
        }

Nota anche le indicazioni in https://github.com/Kotlin/kotlinx.coroutines/blob/native-mt/kotlin-native-sharing.md

Iniziando a farne uso in https://github.com/joreilly/PeopleInSpace

Se si desidera utilizzare le [withTimeout]funzioni nelle coroutine, è necessario modificare l' interfaccia Dispatcherper implementare Delay. Ecco un esempio di come raggiungere questo obiettivo:

@UseExperimental(InternalCoroutinesApi::class)
class UI : CoroutineDispatcher(), Delay {

    override fun dispatch(context: CoroutineContext, block: Runnable) {
        dispatch_async(dispatch_get_main_queue()) {
            try {
                block.run()
            } catch (err: Throwable) {
                throw err
            }
        }
    }

    @InternalCoroutinesApi
    override fun scheduleResumeAfterDelay(timeMillis: Long, continuation: CancellableContinuation<Unit>) {
        dispatch_after(dispatch_time(DISPATCH_TIME_NOW, timeMillis * 1_000_000), dispatch_get_main_queue()) {
            try {
                with(continuation) {
                    resumeUndispatched(Unit)
                }
            } catch (err: Throwable) {
                throw err
            }
        }
    }

    @InternalCoroutinesApi
    override fun invokeOnTimeout(timeMillis: Long, block: Runnable): DisposableHandle {
        val handle = object : DisposableHandle {
             var disposed = false
                private set

            override fun dispose() {
                disposed = true
            }
        }
        dispatch_after(dispatch_time(DISPATCH_TIME_NOW, timeMillis * 1_000_000), dispatch_get_main_queue()) {
            try {
                if (!handle.disposed) {
                    block.run()
                }
            } catch (err: Throwable) {
                throw err
            }
        }

        return handle
    }

}

Questa soluzione può essere facilmente modificata per le tue esigenze.

Ulteriori informazioni sono disponibili in questa discussione .

A volte l'app iOS ha un diverso requisito asincrono con un'app Android. Utilizzare questo codice per problemi di spedizione temporanea

object MainLoopDispatcher: CoroutineDispatcher() {
    override fun dispatch(context: CoroutineContext, block: Runnable) {
        NSRunLoop.mainRunLoop().performBlock {
            block.run()
        }
    }
}

Consultare il forum per questo problema: https://github.com/Kotlin/kotlinx.coroutines/issues/470