yea... I think I understand - if I do launch/async on commonPool. then kotlin will take care of threading pool, and inside the body of the launch I can doo my socket magic?

Injecting

Unconfined

in tests generally seems to be a good idea

Any good sources of information about contexts, other than https://github.com/Kotlin/kotlin-coroutines/blob/master/kotlin-coroutines-informal.md#coroutine-context?

Hello Everyone, We are using JNLP for one of our swing apps. We decided to try and add kotlin coroutines to the app and found that somehow the security settings of Java/JNLP stopped working as expected. We found all sorts of security exceptions started happening of the form

java.security.AccessControlException: access denied ("java.util.PropertyPermission" "os.name" "read")

. We were able to mitigate some of them by wrapping certain calls in

AccessController.doPrivileged(...)

, but that only pushed the problem furthe down and eventually we got NullPointerExceptions deep in our swing code

java.lang.NullPointerException
               at javax.swing.SizeRequirements.calculateAlignedPositions(Unknown Source)
               at javax.swing.BoxLayout.layoutContainer(Unknown Source)
               at java.awt.Container.layout(Unknown Source)
               at java.awt.Container.doLayout(Unknown Source)
               at java.awt.Container.validateTree(Unknown Source)
               at java.awt.Container.validateTree(Unknown Source)
               at java.awt.Container.validate(Unknown Source)
               at java.awt.CardLayout.first(Unknown Source)

Once we reverted the code back to using SwingWorker all those security exceptions disappeared. We are using Oracle Java 8 build 162 with kotlin 1.2.21 and coroutines swing version 0.22. Please let me know if this is a known problem and if I should bother trying to create a bug report for Jetbrains. Many thanks.

Hey somehow I can't find that run {} coroutine builder doc and stuff Looking at : https://github.com/Kotlin/kotlinx.coroutines/blob/master/core/kotlinx-coroutines-core/README.md

@groostav It looks like all you need is to call this top level fun to create your handler instance (it's in the core lib.):

public actual inline fun CoroutineExceptionHandler(crossinline handler: (CoroutineContext, Throwable) -> Unit): CoroutineExceptionHandler =
    object: AbstractCoroutineContextElement(CoroutineExceptionHandler), CoroutineExceptionHandler {
        override fun handleException(context: CoroutineContext, exception: Throwable) =
            handler.invoke(context, exception)
    }

I think you were missing the CoroutineContext's element key companion object, which is what replaces your context with the default one in the lib, but the above should do the trick...

But doesn’t making assumptions about implementation lead to leaky abstractions?

Is this pyramid of death style of receiving from channels pretty common or am I doing something silly?

launch {
        whileSelect {
            channel.onReceive {
                when (it) {
// do stuff
                 }
             }
        }
}

let me check the mockito-kotlin

@gildor thanks it works with mockito-kotlin variant of any()

suspend fun requestSomething() {
return suspendableCoroutine{cont-> 
api.makeACall(object: Response{
     fun onResponse(response: Response){
       cont.resume(response)
}
fun onError(error: Error) {
     cont.resumeWithException(Throwable(error.message)
}
})
}
}

And where I trigger the coroutine:

fun aMethod(){
      launch(Android){
     try{
      requestSomething()
}catch(e: Exception) {
  Timber.d("something went wrong")
}
}
}

And if I recall correctly,

suspendableCoroutine

is a low-level primitive, so it's reasonable to replace it with

CompletableDeferred

. Someone should correct me if I'm wrong, or maybe provide details on why.

how would i write a unit test for that? because as soon as i run this in runBlocking{} in the test doSomething() will be called on the same thread.

@louiscad Experimental is not stopping us. You can post your ideas on the inspections you’d like to have to http://kotl.in/issue

is Mono a monad?

@elizarov the other day someone said

withContext(UI) { }

was equivalent to

async(UI) { }.await()

, but I am having serious problems with the latter, was that not the case?

@mansonheart In general it is all true, but a lot depends on implementation details and specifics.

are there coroutine builders for

javax.concurrent.Task

?

I don't know why, but last time I looked, but turning a callback into coroutines is in the internals KEEP doc. on github kotlinx.coroutines, not in the guide there...

The subject is very nice. I think you need to add few words about Rx.

Could there be any reason why the code in

launch(UI)

is not reached at all after it was run? And the screen in Android device goes black... I tried putting logs there, reducing it to doing almost nothing (only

Log

...)... the screen just blanks out

@bj0 we'll have a new release of

kotlinx.coroutines

when Kotlin 1.2.30 is out. The plan is to have

isActive

extension on

CoroutineContext

, so that you can use

coroutineContext.isActive

. The open question is whether

CoroutineScope

shall be completely deprecated and slated for removal or should we leave

isActive

"shortcut" in the

CoroutineScope

?

Hi, I am not getting how Exception propagation is happening. Here is a pseudo code and test

fun populate(hotels: List<Hotel>) {
        
        val context = newFixedThreadPoolContext(threadpoolCoreSize, "thread-geo")

          context.use { c ->
                val jobs = hotels.map { hotel ->
                    launch(c) {
                        repo.suspendableFun()
                    }
                }
                runBlocking(c) {
                    jobs.forEach({ it.join() })
                }
            }
  }

and

@Test(expectedExceptions = [RuntimeException::class])
    fun `populate should throw exceptionIn`() = runBlocking {
        //and
        given(repo.suspendableFun()).willThrow(RuntimeException(""))

        //when
        victim.populate(hotelList())

        //then
        //The exception is thrown
    }

Hello, I may have strange question, but how can I create some

onComplete

like listener for ReceiveChannel. for now I have

fun <T> ReceiveChannel<T>.onComplete(action: suspend () -> Unit): ReceiveChannel<T> {
    launch(Unconfined) {
        consumeEach { }
        action()
    }
    return this
}

Sorry to mention you @elizarov but don’t you have an idea of how to do that?

i have initializers in a couroutine which are happening apparently within clinit (gsonbuilder) and im getting strange error. Caused by: java.io.FileNotFoundException: null\lib\tzdb.dat (The system cannot find the path specified)

I know I can make a full coroutines Activity where the

onCreate(…)

would be a

suspend fun

so I can right away use

withContext(IO)

for things like SharedPreferences access, but should I? Should I use coroutines everywhere so whenever I need to access even small things in storage that may be cached in memory, I can just do it in a non UI thread coroutineContext and suspend when I can?

@luciofm I was thinking about cancelling the job when the lifecycle state is no longer valid, e.g. cancel

onResume()

coroutine when

onPause()

is called.

How does

delay()

work? A comment in source code (method

scheduleResumeAfterDelay

) says: This implementation is supposed to use dispatcher's native ability for scheduled execution in its thread(s). It means that the method interacts with the thread scheduler to put the current thread into a wait state for the required interval? (like Thread.sleep() https://www.javamex.com/tutorials/threads/sleep.shtml) Or what kind of native ability are we talking about?