Die Funktion withTimeout gibt eine IllegalStateException aus: Es gibt keine Ereignisschleife. Verwenden Sie runBlocking {…}, um eine zu starten. im Kotlin Multiplatform iOS Client

Update: Es funktioniert, wenn ich zuerst eine Coroutine ohne Timeout und dann mit Timeout ausführe. Wenn ich aber zuerst eine Coroutine mit Timeout ausführe, wird mir ein Fehler angezeigt. Gleiches gilt auch für Async.

Ich erstelle eine Demo-Kotlin-Multiplattform-Anwendung, in der ich einen API-Aufruf mit ktor ausführe. Ich möchte eine konfigurierbare Timeout-Funktion auf ktor-Anfrage haben, also verwende ich withTimeout auf Coroutine-Ebene.

Hier ist mein Funktionsaufruf mit Netzwerk-API.

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
}

Hier ist meine AppDispatcher-Klasse für das iOSMain-Modul.

@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()
        }
    }
}

}}

Die Funktion mit dem Timeout gibt mir im iOS-Client den folgenden Fehler.

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

Ich verwende die Version 1.3.2-native-mt-1 der Kotlin-Coroutine-native. Ich habe eine Beispiel-Demo-Anwendung unter der folgenden URL erstellt. https://github.com/dudhatparesh/kotlin-multiplat-platform-example

Wie im obigen Kommentar erwähnt, hatte ich ein ähnliches Problem, aber es stellte sich heraus, dass die native-mtVersion aufgrund von transitiven Abhängigkeiten in anderen Bibliotheken nicht übernommen wurde. Folgendes hinzugefügt und es wird jetzt aufgelöst.

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

Beachten Sie auch die Anleitungen unter https://github.com/Kotlin/kotlinx.coroutines/blob/native-mt/kotlin-native-sharing.md

Nutzen Sie dies in https://github.com/joreilly/PeopleInSpace

Wenn Sie [withTimeout]Funktionen in Coroutinen verwenden möchten, müssen Sie Ihre ändern Dispatcher, um die DelaySchnittstelle zu implementieren . Hier ist ein Beispiel, wie dies erreicht werden kann:

@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
    }

}

Diese Lösung kann leicht an Ihre Bedürfnisse angepasst werden.

Weitere Informationen finden Sie in diesem Thread .

Manchmal hat die iOS-App eine andere asynchrone Anforderung mit einer Android-App. Verwenden Sie diesen Code für vorübergehende Versandprobleme

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

Weitere Informationen zu diesem Problem finden Sie im Forum: https://github.com/Kotlin/kotlinx.coroutines/issues/470