DIY DI delegate acess

App.kt

class App : Application() {

    override fun onCreate() {
        super.onCreate()
        ComponentRouter.init(this) {
            inject(SomeOtherComponentImpl())
            inject(XYComponentImpl())
        }
    }
}

Component.kt

@MainThread
inline fun <reified C : Component> components(): Lazy<C> {
    return ComponentLazy(C::class)
}

class ComponentLazy<C : Component> (
    private val componentClass: KClass<C>
) : Lazy<C> {
    private var cached: C? = null

    override val value: C
        get() {
            val match = ComponentRouter.components.values.find { it.javaClass.interfaces.contains(componentClass.java) }

            requireNotNull(match) {
                ComponentNotRegisteredException(componentClass::simpleName)
            }

            return (match as C).also { cached = it }
        }

    override fun isInitialized() = cached != null
}

ComponentRouter.kt

interface Component

object ComponentRouter {

    val components: MutableMap<Class<Component>, Component> = mutableMapOf()

    fun init(app: Application, block: Initializer.() -> Unit) {
        Initializer().apply {
            this.inject(AppComponentImpl(app))
            block.invoke(this)
        }
    }

    class Initializer {
        fun inject(component: Component) {
            with(component) {
                components[this.javaClass] = component
            }
        }
    }
}

MainActivity.kt

class MainActivity : AppCompatActivity() {

    private val appComponent by components<AppComponent>()

    [...]
}

Updated to properly cache the lazy loaded delegate as well as remove required "tagging" of components. Will now use the java class as the tag to prevent multiples of the same component under different names.