In the `kotlinx.coroutines` library you can start new coroutine using either `launch` (with `join`) or `async` (with `await`). What is the difference between them? 

What is the difference between launch/join and async/await in Kotlin coroutines

I am currently trying to leverage kotlin coroutines more. But I face a problem: when using moshi or okhttp inside these coroutines I get a warning:

 &quot;inappropriate blocking method call&quot;

What is the best way to fix these? I really do not want to be inappropriate ;-)

How to make &quot;inappropriate blocking method call&quot; appropriate?

I&#39;m reading Kotlin Coroutine and know that it is based on `suspend` function. But what does `suspend` mean? 

**Coroutine or function gets suspended?**

From https://kotlinlang.org/docs/reference/coroutines.html

&gt; Basically, coroutines are computations that can be suspended without blocking a thread


I heard people often say &quot;suspend function&quot;. But I think it is the coroutine who gets suspended because it is waiting for the function to finished? &quot;suspend&quot; usually means &quot;cease operation&quot;, in this case the coroutine is idle.

Should we say the coroutine is suspended ?

**Which coroutine gets suspended?**

From https://kotlinlang.org/docs/reference/coroutines.html

&gt; To continue the analogy, await() can be a suspending function (hence also callable from within an async {} block) that suspends a coroutine until some computation is done and returns its result:

    async { // Here I call it the outer async coroutine
        ...
        // Here I call computation the inner coroutine
        val result = computation.await()
        ...
    }
It says &quot;that suspends a coroutine until some computation is done&quot;, but coroutine is like a lightweight thread. So if the coroutine is suspended, how can the computation is done ?

We see `await` is called on `computation`, so it might be `async` that returns `Deferred`, which means it can start another coroutine

    fun computation(): Deferred&lt;Boolean&gt; {
        return async {
            true
        }
    }

The quote say ***that suspends a coroutine***. Does it mean `suspend` the outer `async` coroutine, or `suspend` the inner `computation` coroutine?

Does `suspend` mean that while outer `async` coroutine is waiting (`await`) for the inner `computation` coroutine to finish, it (the outer `async` coroutine) idles (hence the name suspend) and returns thread to the thread pool, and when the child `computation` coroutine finishes, it (the outer `async` coroutine) wakes up, takes another thread from the pool and continues?

The reason I mention the thread is because of https://kotlinlang.org/docs/tutorials/coroutines-basic-jvm.html

&gt; The thread is returned to the pool while the coroutine is waiting, and when the waiting is done, the coroutine resumes on a free thread in the pool

What does the suspend function mean in a Kotlin Coroutine?

Google is deprecating Android AsyncTask API in Android 11 and suggesting to use `java.util.concurrent` instead. you can check out the commit [here](https://android-review.googlesource.com/c/platform/frameworks/base/+/1156409)

     *
     * @deprecated Use the standard &lt;code&gt;java.util.concurrent&lt;/code&gt; or
     *   &lt;a href=&quot;https://developer.android.com/topic/libraries/architecture/coroutines&quot;&gt;
     *   Kotlin concurrency utilities&lt;/a&gt; instead.
     */
    @Deprecated
    public abstract class AsyncTask&lt;Params, Progress, Result&gt; {


If you’re maintaining an older codebase with asynchronous tasks in Android, you’re likely going to have to change it in future. My question is that what should be proper replacement of the code snippet shown below using `java.util.concurrent`. It is a static inner class of an Activity. I am looking for something that will work with `minSdkVersion 16`

    private static class LongRunningTask extends AsyncTask&lt;String, Void, MyPojo&gt; {
            private static final String TAG = MyActivity.LongRunningTask.class.getSimpleName();
            private WeakReference&lt;MyActivity&gt; activityReference;
    
            LongRunningTask(MyActivity context) {
                activityReference = new WeakReference&lt;&gt;(context);
            }
    
            @Override
            protected MyPojo doInBackground(String... params) {
    			// Some long running task
                
            }
    
            @Override
            protected void onPostExecute(MyPojo data) {
    
                MyActivity activity = activityReference.get();
    			activity.progressBar.setVisibility(View.GONE);
    			populateData(activity, data) ;
            }     
    
    
        }





The AsyncTask API is deprecated in Android 11. What are the alternatives?

I&#39;m trying to trigger an update on LiveData from a coroutine:

    object AddressList: MutableLiveData&lt;List&lt;Address&gt;&gt;()
    fun getAddressesLiveData(): LiveData&lt;List&lt;Address&gt;&gt; {
        AddressList.value = listOf()
        GlobalScope.launch {
            AddressList.value = getAddressList()
        }
        return AddressList
    }

but I get the following error:

&gt; IllegalStateException: Cannot invoke setValue on a background thread

Is there a way to make it work with coroutines?


MutableLiveData: Cannot invoke setValue on a background thread from Coroutine

I have been reading [kotlin docs][1], and if I understood correctly the two Kotlin functions work as follows :

 1. `withContext(context)`: switches the context of the current coroutine, when the given block executes, the coroutine switches back to previous context.
 2. `async(context)`: Starts a new coroutine in the given context and if we call `.await()` on the returned `Deferred` task, it will suspends the calling coroutine and resume when the block executing inside the spawned coroutine returns.

Now for the following two versions of `code` :

**Version1:**

      launch(){
        block1()
        val returned = async(context){
          block2()
        }.await()
        block3()
      }

**Version2:**

      launch(){
        block1()
         val returned = withContext(context){
          block2()
        }
        block3()
      }

 1. In both versions block1(), block3() execute in default context(commonpool?) where as block2() executes in the given context.
 2. The overall execution is synchronous with block1() -&gt; block2() -&gt; block3() order.
 3. Only difference I see is that version1 creates another coroutine, where as version2 executes only one coroutine while switching context.

My questions are :

1. Isn&#39;t it always better to use `withContext` rather than `async-await` as it is functionally similar, but doesn&#39;t create another coroutine. Large numbers of coroutines, although lightweight, could still be a problem in demanding applications.

2. Is there a case `async-await` is more preferable to `withContext`?

**Update:**
[Kotlin 1.2.50][2] now has a code inspection where it can convert `async(ctx) { }.await() to withContext(ctx) { }`.


  [1]: https://github.com/Kotlin/kotlinx.coroutines/blob/master/coroutines-guide.md
  [2]: https://blog.jetbrains.com/kotlin/2018/06/kotlin-1-2-50-is-out/

Kotlin: withContext() vs Async-await

Is there any specific language implementation in Kotlin, which differs it from another languages implementation of coroutines? 

 - What means that coroutine is like light-weight thread?
 - What is the difference?
 - Are kotlin coroutines actually running in parallely / concurrently?
 - Even in multi-core system, there is only one coroutine running at any given time (is it right?)

Here I&#39;m starting 100000 coroutines, what happens behind this code? 

    for(i in 0..100000){
       async(CommonPool){
        //run long running operations
      }
    }

 

 


Difference between thread and coroutine in Kotlin

I have a general question with a specific example:  I&#39;d like to use Kotlin coroutine magic instead of callback hell in Android when taking a picture.


    manager.openCamera(cameraId, object : CameraDevice.StateCallback() {
        override fun onOpened(openedCameraDevice: CameraDevice) {
            println(&quot;Camera onOpened&quot;)
            // even more callbacks with openedCameraDevice.createCaptureRequest()....
        }

        override fun onDisconnected(cameraDevice: CameraDevice) {
            println(&quot;Camera onDisconnected&quot;)
            cameraDevice.close()
        }
        ...

How would I convert that to something less ugly?  ***Is it possible to take an average callback with three or so functions, and turn it into a promise-chain by designating the primary flow as the promise-result path?*** And if so, should/do I use coroutines to make it async?

I&#39;d love something with async and .await that would result in

    manager.open(cameraId).await().createCaptureRequest()

I&#39;m trying to do it through something like the following, but I don&#39;t think I&#39;m using `CompletableDeferred` right!

    suspend fun CameraManager.open(cameraId:String): CameraDevice {
        val response = CompletableDeferred&lt;CameraDevice&gt;()
        this.openCamera(cameraId, object : CameraDevice.StateCallback() {
            override fun onOpened(cameraDevice: CameraDevice) {
                println(&quot;camera onOpened $cameraDevice&quot;)
                response.complete(cameraDevice)
            }
    
            override fun onDisconnected(cameraDevice: CameraDevice) {
                response.completeExceptionally(Exception(&quot;Camera onDisconnected $cameraDevice&quot;))
                cameraDevice.close()
            }
    
            override fun onError(cameraDevice: CameraDevice, error: Int) {
                response.completeExceptionally(Exception(&quot;Camera onError $cameraDevice $error&quot;))
                cameraDevice.close()
            }
        }, Handler())
        return response.await()
    }

Existing 3-function callback to Kotlin Coroutines

Can Kotlin coroutines be used in production, and what does their experimental status mean?


Can &quot;experimental&quot; Kotlin coroutines be used in production?

I was reading [Coroutine Basics][1] trying to understand and learn it.

There is a part there with this code:

    
    fun main() = runBlocking { // this: CoroutineScope
        launch { 
            delay(200L)
            println(&quot;Task from runBlocking&quot;)
        }
    
        coroutineScope { // Creates a new coroutine scope
            launch {
                delay(900L) 
                println(&quot;Task from nested launch&quot;)
            }
    
            delay(100L)
            println(&quot;Task from coroutine scope&quot;) // This line will be printed before nested launch
        }
    
        println(&quot;Coroutine scope is over&quot;) // This line is not printed until nested launch completes
    }

The output goes like so:

    Task from coroutine scope
    Task from runBlocking
    Task from nested launch
    Coroutine scope is over

My question is why this line:

     println(&quot;Coroutine scope is over&quot;) // This line is not printed until nested launch completes

is called always last?

Shouldn&#39;t it be called since the:

    coroutineScope { // Creates a new coroutine scope
        ....
    }

is suspended?

There is also a note there:

&gt; The main difference between runBlocking and coroutineScope is that the latter does not block the current thread while waiting for all children to complete.

I dont understand how coroutineScope and runBlocking are different here? coroutineScope looks like its blocking since it only gets to the last line when it is done.

Can anyone enlighten me here?

Thanks in advance.

  [1]: https://kotlinlang.org/docs/reference/coroutines/basics.html

Coroutines: runBlocking vs coroutineScope

Android studio gave the error:

    Execution failed for task &#39;:app:kaptDebugKotlin&#39;.
    &gt; A failure occurred while executing org.jetbrains.kotlin.gradle.internal.KaptExecution
       &gt; java.lang.reflect.InvocationTargetException (no error message)

I want to add in my project Kotlin Coroutines and use it with Room database. But after added all libraries I got this error. This is all information from the compiler.

I have identified, This is because of the annotation @Database. If I removed this annotation, the error don&#39;t appear, but Room is not working too.

My gradle file:

    apply plugin: &#39;com.android.application&#39;
    apply plugin: &#39;kotlin-android&#39;
    apply plugin: &#39;kotlin-android-extensions&#39;
    apply plugin: &#39;kotlin-kapt&#39;
    //apply plugin: &#39;androidx.navigation.safeargs&#39;
    
    kotlin {
        experimental {
            coroutines &#39;enable&#39;
        }
    }
    
    android {
        compileSdkVersion 29
        defaultConfig {
            applicationId &quot;com.bestcred.coursetthree&quot;
            minSdkVersion 21
            targetSdkVersion 29
            versionCode 1
            versionName &quot;1.0&quot;
    
            testInstrumentationRunner &quot;androidx.test.runner.AndroidJUnitRunner&quot;
            //vectorDrawables.useSupportLibrary = true
        }
        buildTypes {
            release {
                minifyEnabled false
                proguardFiles getDefaultProguardFile(&#39;proguard-android.txt&#39;), &#39;proguard-rules.pro&#39;
            }
        }
    
        // Enables data binding.
        buildFeatures {
            dataBinding true
        }
    }
    
    dependencies {
    
    
        implementation &quot;org.jetbrains.kotlin:kotlin-stdlib-jdk7:$kotlin_version&quot;
    
        // Support libraries
        implementation &quot;androidx.appcompat:appcompat:1.2.0&quot;
        implementation &#39;com.google.android.material:material:1.2.0&#39;
        implementation &quot;androidx.fragment:fragment:1.2.5&quot;
        implementation &quot;androidx.constraintlayout:constraintlayout:2.0.0&quot;
    
        // Android KTX
        implementation &#39;androidx.core:core-ktx:1.3.1&#39;
    
        // Room and Lifecycle dependencies
        implementation &quot;androidx.room:room-runtime:$room_version&quot;
        implementation &#39;androidx.legacy:legacy-support-v4:1.0.0&#39;
        kapt &quot;android.arch.persistence.room:compiler:$room_version&quot;
    
        // Kotlin Extensions and Coroutines support for Room
        implementation &quot;androidx.room:room-ktx:$room_version&quot;
    
        // Coroutines
        implementation &quot;org.jetbrains.kotlinx:kotlinx-coroutines-core:$coroutine_version&quot;
        implementation &quot;org.jetbrains.kotlinx:kotlinx-coroutines-android:$coroutine_version&quot;
    
    }

    kotlin_version = &quot;1.4.0&quot;
    room_version = &quot;2.2.5&quot;
    coroutine_version = &#39;1.3.9&#39;

I update Room version and add Kotlin Coroutines. What&#39;s problem?[![enter image description here][1]][1]


  [1]: https://i.stack.imgur.com/Apjb0.png

A failure occurred while executing org.jetbrains.kotlin.gradle.internal.KaptExecution &gt; java.lang.reflect.InvocationTargetException (no error message)

This question is related to my question on [existing coroutine implementations in Java][1].  If, as I suspect, it turns out that there is no full implementation of coroutines currently available in Java, what would be required to implement them?

As I said in that question, I know about the following:

  1.  You can implement &quot;coroutines&quot; as threads/thread pools behind the scenes.
  2.  You can do tricksy things with JVM bytecode behind the scenes to make coroutines possible.
  3.  The so-called &quot;Da Vinci Machine&quot; JVM implementation has primitives that make coroutines doable without
      bytecode manipulation.
  4.  There are various JNI-based approaches to coroutines also possible.

I&#39;ll address each one&#39;s deficiencies in turn.

## Thread-based coroutines ##

This &quot;solution&quot; is pathological.  The whole point of coroutines is to *avoid* the overhead of threading, locking, kernel scheduling, etc.  Coroutines are supposed to be light and fast and to execute only in user space.  Implementing them in terms of full-tilt threads with tight restrictions gets rid of all the advantages.

## JVM bytecode manipulation ##

This solution is more practical, albeit a bit difficult to pull off.  This is roughly the same as jumping down into assembly language for coroutine libraries in C (which is how many of them work) with the advantage that you have only one architecture to worry about and get right.

It also ties you down to only running your code on fully-compliant JVM stacks (which means, for example, no Android) unless you can find a way to do the same thing on the non-compliant stack.  If you do find a way to do this, however, you have now doubled your system complexity and testing needs.

## The Da Vinci Machine ##

The Da Vinci Machine is cool for experimentation, but since it is not a standard JVM its features aren&#39;t going to be available everywhere.  Indeed I suspect most production environments would specifically forbid the use of the Da Vinci Machine.  Thus I could use this to make cool experiments but not for any code I expect to release to the real world.

This also has the added problem similar to the JVM bytecode manipulation solution above: won&#39;t work on alternative stacks (like Android&#39;s).

## JNI implementation ##

This solution renders the point of doing this in Java at all moot.  Each combination of CPU and operating system requires independent testing and each is a point of potentially frustrating subtle failure.  Alternatively, of course, I could tie myself down to one platform entirely but this, too, makes the point of doing things in Java entirely moot.

So...

Is there any way to implement coroutines in Java without using one of these four techniques?  Or will I be forced to use the one of those four that smells the least (JVM manipulation) instead?

----------

*Edited to add:*

Just to ensure that confusion is contained, this is a *related* question to [my other one][1], but not the same.  That one is looking for an **existing** implementation in a bid to avoid reinventing the wheel unnecessarily.  This one is a question relating to how one would go about implementing coroutines in Java should the other prove unanswerable.  The intent is to keep different questions on different threads.

  [1]: https://stackoverflow.com/questions/2846428/coroutines-in-java &quot;StackOverflow: Coroutines in Java&quot;

Implementing coroutines in Java

I have some questions about **Kotlin Flow**

1. I can observe `LiveData` from multiple Fragments. Can I do this with `Flow`? If yes then how?
2. We can have multiple `LiveData` from a single `LiveData` using `map`&amp; `switchMap`. Is there any way to have multiple `Flow` from a single source `Flow`?
3. Using `MutableLiveData` I can update data from anywhere using the variable reference. Is there any way to do the same with `Flow`?

I have a use-case like: I will observe a `SharedPreferences` using `callbackFlow{...}` which will give me a single source Flow. From that Flow, I want to create multiple Flow for each key-value pair.

These might sound silly questions. I am new to Rx and Flow world. 

Kotlin Flow vs Android LiveData

Assume we have the following suspend function:

    suspend fun doSomething(): List&lt;MyClass&gt; { ... }

If I want to call this function in one of my existing Java classes (which I&#39;m not able to convert to Kotlin for now) and get its return value I have to provide a `Continuation&lt;? super List&lt;MyClass&gt;&gt;` as its parameter (Obviously). 

My question is, How can I implement one. Specially its `getContext` getter.

Call Kotlin suspend function in Java class

I am used to working with `AsyncTask` and understand it pretty well due to its simplicity. But `Coroutines` are confusing to me. Can you please explain to me in a simple way what is the difference and purpose of each of the following?

1. `GlobalScope.launch(Dispatchers.IO) {}`
2. `GlobalScope.launch{}`
3. `CoroutineScope(Dispatchers.IO).launch{}`
4. `lifecycleScope.launch(Dispatchers.IO){}`
5. `lifecycleScope.launch{}`

GlobalScope vs CoroutineScope vs lifecycleScope

Trying to run some examples for Kotlin coroutines, but can&#39;t build my project. I&#39;m using the latest gradle release - 4.1

Any suggestions what to check/fix?

Here is `build.gradle`

    buildscript {
        ext.kotlin_version = &#39;1.1.4-3&#39;

        repositories {
            mavenCentral()
        }

        dependencies {
            classpath &quot;org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version&quot;
        }
    }

    apply plugin: &#39;kotlin&#39;
    apply plugin: &#39;application&#39;

    kotlin {
        repositories {
            jcenter()
        }

        experimental {
            coroutines &#39;enable&#39;
        }

        dependencies {
            compile &quot;org.jetbrains.kotlinx:kotlinx-coroutines-core:0.18&quot;
        }
    }

and the `main.kt`

    fun main(args: Array&lt;String&gt;) {
        launch (CommonPool) {
            delay(1000L)
            println(&quot;World!&quot;)
        }

        println(&quot;Hello, &quot;)
        Thread.sleep(2000L)
    }

when I run `gradle compileKotlin` I get the following

    e: /Users/philippgrigoryev/projects/kotlin-coroutines/src/main/kotlin/main.kt: (2, 5): Unresolved reference: launch
    e: /Users/philippgrigoryev/projects/kotlin-coroutines/src/main/kotlin/main.kt: (2, 13): Unresolved reference: CommonPool
    e: /Users/philippgrigoryev/projects/kotlin-coroutines/src/main/kotlin/main.kt: (3, 9): Unresolved reference: delay`

Unresolved reference: launch

Can anyone explain the difference between them? I think scope provides a reference(e.g. Job) to cancel them and context provides a reference to underlying thread. Is that so?

Kotlin: Coroutines scope vs Coroutine context

I am calling suspended function from onCreate(...)

    override fun onCreate(savedInstanceState: Bundle?) {
        ...
        ...
        callGetApi()
    }

and the suspended function is:-

    suspend fun callGetApi() {....}

But the error shows up *Suspend function &#39;callGetApi&#39; should be called only from a coroutine or another suspend function*

Suspend function &#39;callGetApi&#39; should be called only from a coroutine or another suspend function

Please find below a function using a coroutine to replace callback : 

    override suspend fun signUp(authentication: Authentication): AuthenticationError {
        return suspendCancellableCoroutine {
            auth.createUserWithEmailAndPassword(authentication.email, authentication.password)
                .addOnCompleteListener(activityLifeCycleService.getActivity()) { task -&gt;
                    if (task.isSuccessful) {
                        it.resume(AuthenticationError.SignUpSuccess)
                    } else {
                        Log.w(this.javaClass.name, &quot;createUserWithEmail:failure&quot;, task.exception)
                        it.resume(AuthenticationError.SignUpFail)
                    }
                }
        }
    }

Now I would like to unit testing this function. I am using Mockk : 

      @Test
      fun `signup() must be delegated to createUserWithEmailAndPassword()`() = runBlockingTest {
    
          val listener = slot&lt;OnCompleteListener&lt;AuthResult&gt;&gt;()
          val authentication = mockk&lt;Authentication&gt; {
            every { email } returns &quot;email&quot;
            every { password } returns &quot;pswd&quot;
          }
          val task = mockk&lt;Task&lt;AuthResult&gt;&gt; {
            every { isSuccessful } returns true
          }
    
          every { auth.createUserWithEmailAndPassword(&quot;email&quot;, &quot;pswd&quot;) } returns
              mockk {
                every { addOnCompleteListener(activity, capture(listener)) } returns mockk()
              }
    
        service.signUp(authentication)
    
          listener.captured.onComplete(task)
        }

Unfortunately this test failed due to the following exception : `java.lang.IllegalStateException: This job has not completed yet` 

I tried to replace `runBlockingTest` with `runBlocking` but the test seems to wait in an infinite loop.

Can someone help me with this UT please?

Thanks in advance

Unit testing coroutines runBlockingTest: This job has not completed yet

I&#39;m recently studying and reading a lot about [Flow][1] and Kotlin Coroutines. But I still get confused about when I should use `Flow` and when I should use `Channel`.

At the beginning it looked more simple. Working with hot streams of data? `Channel`. Cold ones? `Flows`. Same goes if you need to listen to streams of data from more than a single place; if that&#39;s the case `Channel` is the choice to go. There are still a lot of examples and questions.

But recently `FlowChannels` where introduced, together with tons of methods and classes that encourage the use of `Flow`, which facilities transforming `Channels` into `Flows` and so on. With all this new stuff coming on each Kotlin release I am getting more and more confused. So the question is:

When should I use *Channel* and when should I use *Flow*?

  [1]: https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines.flow/-flow/

Kotlin Coroutines: Channel vs Flow

Kotlin corutines is sugar for finite state machine and some task runner (for example, default ForkJoinPool). https://github.com/Kotlin/kotlin-coroutines/blob/master/kotlin-coroutines-informal.md#implementation-details 

In other words, there is no runtime coroutines in java/kotlin runtime yet (but this can change with http://cr.openjdk.java.net/~rpressler/loom/Loom-Proposal.html ). Kotlin coroutine is just sequential of tasks, which are executed one by one. Each task can be executed in any thread from thread pool.

Go runtime supports &quot;coroutines&quot;. But goroutines is not the real coroutines. Goroutines does not allow to set yield points in program. Also, Go does not allow to set custom thread pool. You can to set only size of threads in default pool. 

First difference between kotlin coroutines and goroutines is Go runtime manages which coroutine is running at this moment. When goroutine are blocked at some IO operation (or synchronization primitives), Go choices next Job to execute it. In JVM there is no intellectual job switching in such terms. 

Because of this, Go can cheaply change currently running job. Go has only to change few registries &lt;a href=&quot;https://groups.google.com/forum/#!msg/golang-nuts/j51G7ieoKh4/wxNaKkFEfvcJ&quot;&gt;https://groups.google.com/forum/#!msg/golang-nuts/j51G7ieoKh4/wxNaKkFEfvcJ&lt;/a&gt;. But some people say, that JVM can use stack of threads instead of using registers. So there is no saving and loading of registers at all.

The second difference between kotlin coroutines and goroutines is type of coroutines. Kotlin coroutines is stackless coroutines. Goroutines are stackful coroutines. All state of Kotlin coroutines are stored in Kotlin context, which is stored in heap. Goroutines state is stored in registers and thread stack.

I want to know, which coroutines (goroutines and kotlin coroutines) are faster in IO bound tasks? CPU bound tasks? What about memory consumption?

Which of coroutines (goroutines and kotlin coroutines) are faster?

I am using kotlin coroutines for network request using extension method to call class in retrofit like this

    

    public suspend fun &lt;T : Any&gt; Call&lt;T&gt;.await(): T {

      return suspendCancellableCoroutine { continuation -&gt; 

        enqueue(object : Callback&lt;T&gt; {

            override fun onResponse(call: Call&lt;T&gt;?, response: Response&lt;T?&gt;) {
                if (response.isSuccessful) {
                    val body = response.body()
                    if (body == null) {
                        continuation.resumeWithException(
                                NullPointerException(&quot;Response body is null&quot;)
                        )
                    } else {
                        continuation.resume(body)
                    }
                } else {
                    continuation.resumeWithException(HttpException(response))
                }
            }

            override fun onFailure(call: Call&lt;T&gt;, t: Throwable) {
                // Don&#39;t bother with resuming the continuation if it is already cancelled.
                if (continuation.isCancelled) return
                continuation.resumeWithException(t)
            }
        })

          registerOnCompletion(continuation)
      }
    }


then from calling side i am using above method like this 

    private fun getArticles()  = launch(UI) {

        loading.value = true
        try {
            val networkResult = api.getArticle().await()
            articles.value =  networkResult

        }catch (e: Throwable){
            e.printStackTrace()
            message.value = e.message

        }finally {
            loading.value = false
        }

    }

i  want to exponential retry this api call in some case i.e (IOException) how can i achieve it ??


All Kotlin Coroutines Solutions on Gang of Coders

Total of 22 Kotlin Coroutines Solutions