omkar-tenkale

suspendCoroutineUninterceptedOrReturn<Unit> { cont ->
    Compressor.compress(image)(
        onSuccess = {
            DispatcherContinuation(cont.context, cont).resumeWith(Result.success(Unit))
        }
    )
    COROUTINE_SUSPENDED
}

omkar-tenkale

fun copyFiles(files: List<File>, destination: File){
   for(file in files){
      launch(Dispatcher.Background){
         ...
      }
   }
}

omkar-tenkale

class FileCopyFragment : Fragment() {
    fun copyFiles(files: List<File>, destination: File) {
        launch(Dispatcher.Background) {
            for (file in files) {
                val needsOverride = destination.listFiles()?.any { it.name == file.name } ?: false
                if (needsOverride && !confirmFileOverride(file.name)) {
                    continue
                }
                file.copyTo(destination)
            }

omkar-tenkale

fun <T> (suspend () -> T).createCoroutine(
    completion: Continuation<T>
): Continuation<Unit> {
    val coroutine = createCoroutineUnintercepted(completion)
    return DispatcherContinuation(completion.context,coroutine)
}

omkar-tenkale

import android.os.Handler
import android.os.Looper
import kotlin.concurrent.thread
import kotlin.coroutines.Continuation
import kotlin.coroutines.CoroutineContext
import kotlin.coroutines.intrinsics.createCoroutineUnintercepted
import kotlin.coroutines.intrinsics.suspendCoroutineUninterceptedOrReturn
import kotlin.coroutines.intrinsics.COROUTINE_SUSPENDED

sealed class Dispatcher : CoroutineContext.Element {

omkar-tenkale

suspend fun <T> suspendCoroutine(block: (Continuation<T>) -> Unit): T {
    return suspendCoroutineUninterceptedOrReturn { cont ->
        // block(cont)
        val dispatchedContinuation = DispatcherContinuation(cont.context, cont)
        block(dispatchedContinuation)
        COROUTINE_SUSPENDED
    }
}

omkar-tenkale

// Resumes a coroutine on specified dispatcher
class DispatcherContinuation<T>(
    override val context: CoroutineContext,
    val continuation: Continuation<T>
) : Continuation<T> {
    override fun resumeWith(result: Result<T>) {
        when (context as Dispatcher) {
            Dispatcher.Main -> Handler(Looper.getMainLooper()).post { 
                continuation.resumeWith(result) 
            }

omkar-tenkale

fun launch(dispatcher: Dispatcher, block: suspend () -> Unit) {
    val callback = object : Continuation<Unit> {
        override val context: CoroutineContext = dispatcher
        override fun resumeWith(result: Result<Unit>) {}
    }
    val coroutine = block.createCoroutineUnintercepted(callback)
    // Duplicate code #1
    when (dispatcher) {
        Dispatcher.Main -> Handler(Looper.getMainLooper()).post {
            coroutine.resumeWith(Result.success(Unit))

omkar-tenkale

launch(Dispatcher.Main){
    println("Download Started")
    // launch(Dispatcher.Background)
    withContext(Dispatcher.Background) {
        println("Download in progress")
        downloader.download()
    }
    println("Download Complete")
}

omkar-tenkale

suspend fun <R> withContext(dispatcher: Dispatcher, block: suspend () -> R): R {
    return suspendCoroutineUninterceptedOrReturn<R> { cont ->
        val callback = object : Continuation<R> {
            override val context = dispatcher

            override fun resumeWith(result: Result<R>) {
                when (cont.context as Dispatcher) {
                    Dispatcher.Main -> Handler(Looper.getMainLooper()).post { 
                        cont.resumeWith(result) 
                    }