If I'm using retrofit 2.6.0 and using the suspend fun do I have to also add the CoroutineCallAdapterFactory when creating the retrofit object?

Hello I'm moving to the new version of retrofit and I was using a convertor that was creating a

ResultWrapperT

from

CallT

but now reading this answer [1] from stackoverflow then I realized that if I'm using

suspended fun

I do not have to add the

CallT

so, how do I do the change now? I was using this method :

fun <reified T:Any> execute(function: () -> Call<T>): ResultWrapperT =
        try {
            when (T::class) {
                Unit::class -> function().execute().let {
                    ResultWrapper.Success(Unit as T)
                }
                else -> function().execute().body()?.let {
                    ResultWrapper.Success(it)
                } ?: ResultWrapper.Error(Exception("no body there"))
            }
        } catch (e: Exception) {
            ResultWrapper.Exception(e)
        }

Any idea? The problem now is that as it's not a

CallT

I do not have the

execute()

method... [1] : https://stackoverflow.com/a/57810074/4329781

Sequences supply data on demand but in this case the producer is pushing the data. So I guess I might need a channel? 🤔

Folks, I am writing my first coroutine. In the follow piece of code, I am fetching a bunch of objects and then doing a IO call with other service. Need some feedback whether my understanding of coroutine is correct.

val allWarehouses: List<Warehouse> = getWarehouses()

 GlobalScope.launch(<http://Dispatchers.IO|Dispatchers.IO>) {
        allWarehouses.forEach { warehouse ->
        	val notes = getNotes()
			// I want to run this loop in parallel
			notes.forEach {
			   serviceClient.markDone(note)  // this is an IO call 
			}
        }
}

I want to run the forEach operation in parallel. Is this the right way of doing?

For parallel execution, is this the right way

notes.parallelStream().forEach { println(it) }

Is there any simple way to implement

Deferred

interface? I was trying to delegate that interface to an instance returned by

async

function, but it doesn't work well.

class MyDeferred<T>(val original: Deferred<T>) : Deferred<T> by original

MyDeferred(async{ ...} )

I want to be able to call some code on async completition or execption, maybe there is another way?

How might I create a flow of a sealed class? I have something like this:

val events =
  flowOf(
      callbackFlow { }.map { SealedClass.Property1 },
      callbackFlow { }.map { SealedClass.Property2 },
      BroadcastChannel(1) .asFlow().map { SealedClass.Property3 }
).flattenMerge()

But, when I

offer

to the broadcast channel nothing is emitted from events. The callback flows however, work fine.

Which is better?:

.flow().map { ... }.toList()

or

.flow().toList().map { ... }

How can I return the String "newURL" with coroutines ? fun firstServerRequest(): String? { val service = pokemonNetwork.service service.getAllPokemonDatas(50,0).enqueue(object : Callback<PokemonList> { override fun onFailure(call: Call<PokemonList>, t: Throwable) { } override fun onResponse(call: Call<PokemonList>, response: Response<PokemonList>) { response.body()?.results?.forEach { pokemon -> var newURL = pokemon.url } } }) return newURL }

Is there a way to use select (or some other similar mechanism) to select for messages on an arbitrary set of Channels not known at compile time (provided the channels have the same message type)?

Let's have a channel (ConflatedBroadcastChannel) wired in a model. What is an alternative to

SingleLiveData<T>

, e.g. something what observe value just once, but on multiple places (observers).

Cross-posting from #android: https://kotlinlang.slack.com/archives/C0B8M7BUY/p1571753686276700

is there a recommended way to schedule a periodic task with coroutines? i see

ticker

, but it’s marked as obsolete and it’s unclear why

Hi all, I'm playing with Flow and error handling. I'm doing somethink like: (1..5).asFlow().onEach{ //throw error }.retryWhen { c, a -> ... } But the flow restarts from the beginning. What is the best way to skip the emitted element that cause the error and restart from the next one?

I’m seeing some pretty disappointing CPU usage from a low throughput coroutines workload (sending ~40-50 network requests per second) that is all non-blocking I/O, barely any CPU work. Using the async profiler shows the DefaultDispatcher threads are spending the majority of their time in the coroutines scheduler (mostly in

Worker.doPark

or

WorkQueue.trySteal

. Is this… expected?

guess this is coroutine related.. why can i not do

suspend operator get(id: String)

and is there any way to use operator overloading with suspending functions ?

Does the KotlinX Coroutines project ( https://github.com/Kotlin/kotlinx.coroutines ) accept PR's for adding a new scheduler?

can anyone point me in the right direction on a strategy for how I might use Flow's

debounce

to debounce text changes from an Android EditText? I've done this previously using RxJava but RxAndroid did the hard work there with

RxTextView.textChanges

.. I'm wondering how I can achieve this in the world of coroutines/flow

in

suspendCancellableCoroutine { continuation ->

do we need to check anything like

isActive or isCancelled

before call

resumeWith

and why?

Hi, is it good to use multiple

combine

in flows like below

Firestore.getFlow1().combine(Firestore.getFlow2()) { f1, f2 -> Result(f1,f2)}
                .combine(Firestore.getFlow3()) { f3, result -> result.f3 = f3 }
                .collect { _liveData.value = it}

Here

Firesstore.get*

all are wrappers that converts firestores snapshow listeners to flow, so here i have to listen three flows and want to combine them . is it good to do like this or there is any other way also ?

How does OkHttp compare to Ktor Client? Seems they land on similar use cases? Why might I prefer one over the other?

What is the recommanded what to turn Javascript callback based API like

EventSource

to a

Flow

that emits the data received by the

onmessage

callback ?

any database driver implementation with coroutines?

Let’s say I have a

CoroutineScope

backed by a multi-thread dispatcher. I also have a

Channel<Int>

that needs to receive incoming messages.

val scope = CoroutineScope(Dispatchers.Default)
val channel: Channel<Int> = TODO()

fun onNewInt launch`(newInt: Int) {
  // `newInt` is delivered from outside a coroutine
  // what is the appropriate way to emit to the channel? 
}

I see two possibilities (see code snippet)

What would be the idiomatic way to emit a

Flow<Unit>

every 40 milliseconds? old solution:

channelFlow<Unit> {
  while (isActive) {
    delay(40)
    send(Unit)
  }
}

new, better solution:

flow {
    while (true) {
        delay(40)
        emit(Unit)
    }
}

can someone point me to some information on calling a

suspend fun

from a java class with Java 7 compatibility? I found some information by googling on how to do this with Java 8+, but not Java 7

Hi there. I couldn’t get why this code was being run on the main thread (why wouldn’t suspend function create its own thread):

override suspend fun createAccount(
        name: String,
        avatarPath: String?
    ) : AccountEntity {

        Timber.d("Thread: ${Thread.currentThread().name}")

        return service.createAccount(name, avatarPath).let { response ->
            AccountEntity(
                id = response.id,
                name = response.name,
                avatar = response.avatar.toEntity()
            )
        }
    }

I launch inside

ViewModelScope

. Any help will be appreciated!

Why is

viewModelScope

being pushed by the Android team? It requires a bunch of workarounds that would be completely unnecessary if the

CoroutineScope

was just injected into the

ViewModel

what is the best dispatcher to use for user input?