Using kotlin's features to inject values that are suspend computed into any class constructor

SuspendClassInitializerExample.kt

import android.os.Looper
import kotlinx.coroutines.experimental.*
import kotlin.system.measureTimeMillis

abstract class SuspendClassInitializer<out T> constructor(
        private val initDispatcher: CoroutineDispatcher,
        instanceFactory: () -> T
) {

    private val delegate = lazy(instanceFactory)
    private val instance by delegate

    constructor(instanceFactory: () -> T) : this(Dispatchers.Default, instanceFactory)

    suspend operator fun invoke(): T {
        return if (delegate.isInitialized()) instance else withContext(initDispatcher) {
            check(Thread.currentThread() != Looper.getMainLooper().thread)
            instance
        }
    }
}

class HeavyClass private constructor() {
    companion object : SuspendClassInitializer<HeavyClass>(::HeavyClass)

    var data: Int = -1

    init {
        // Artificially blocking the initialization of the class
        runBlocking {
            println("Initializing something heavy..")
            delay(3000)
            data = 42
            println("Finally, it is initialized!")
        }
    }
}

fun example() {
    println("Will init the heavy class")

    GlobalScope.launch {
        val t = measureTimeMillis {
            val heavyClass = HeavyClass()
            println("The data is: ${heavyClass.data}")
        }
        println("It took ${t}ms to init the heavy class")
    }

    println("Do something else here")
}