Fungsi withTimeout memberikan IllegalStateException: Tidak ada loop acara. Gunakan runBlocking {...} untuk memulai. di klien Kotlin Multiplatform iOS

Pembaruan: Ini berfungsi jika saya pertama kali menjalankan coroutine tanpa batas waktu dan kemudian dengan TimeTime. Tetapi jika saya menjalankan coroutine withTimeout terlebih dahulu maka itu memberi saya kesalahan. Hal yang sama berlaku untuk Async juga.

Saya membuat aplikasi multiplatform demo kotlin tempat saya mengeksekusi panggilan API dengan ktor. Saya ingin memiliki fungsi batas waktu yang dapat dikonfigurasi pada permintaan ktor jadi saya menggunakan withTimeout di tingkat coroutine.

Inilah panggilan fungsi saya dengan API jaringan.

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
}

Ini adalah kelas AppDispatcher saya untuk modul 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()
        }
    }
}

}

jadi fungsi dengan batas waktu memberi saya kesalahan berikut di klien iOS.

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

Saya menggunakan versi 1.3.2-native-mt-1 dari kotlin-coroutine-native. Saya telah membuat contoh aplikasi demo di URL berikut. https://github.com/dudhatparesh/kotlin-multiplat-platform-example

Jadi, seperti yang disebutkan dalam komentar di atas saya memiliki masalah yang sama tetapi ternyata itu tidak mengambil native-mtversi karena dependensi transitif di perpustakaan lain. Ditambahkan berikut ini dan sedang diselesaikan sekarang.

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

Perhatikan juga panduan di https://github.com/Kotlin/kotlinx.coroutines/blob/native-mt/kotlin-native-sharing.md

Mulai memanfaatkan ini di https://github.com/joreilly/PeopleInSpace

Jika Anda ingin menggunakan [withTimeout]fungsi di coroutine, Anda harus memodifikasi Anda Dispatcheruntuk mengimplementasikan Delayantarmuka. Berikut adalah contoh bagaimana hal ini dapat dicapai:

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

}

Solusi ini dapat dengan mudah dimodifikasi untuk kebutuhan Anda.

Informasi lebih lanjut dapat ditemukan di utas ini .

Terkadang aplikasi ios memiliki persyaratan async yang berbeda dengan aplikasi android. Gunakan kode ini untuk masalah pengiriman sementara

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

Silakan lihat forum untuk masalah ini: https://github.com/Kotlin/kotlinx.coroutines/issues/470