Dagger 2 `@PerScreen` scope surviving configuration change

App.kt

class App : Application() {

    @Inject
    lateinit var applicationInjector: ApplicationInjector

    override fun onCreate() {
        super.onCreate()

        DaggerAppComponent.create().inject(this)
        registerActivityLifecycleCallbacks(applicationInjector)
    }

}

AppComponent.kt

@Singleton
@Component(modules = [ScreenModule::class])
interface AppComponent {

    fun inject(app: App)

    fun getBinding(): Map<Class<out Activity>, Provider<ProvidesActivityInjectorFactories.Builder>>
}

ApplicationInjector.kt

@Singleton
class ApplicationInjector @Inject constructor(
        private val injectorFactories: Map<Class<out Activity>, @JvmSuppressWildcards Provider<ProvidesActivityInjectorFactories.Builder>>
) : Application.ActivityLifecycleCallbacks {

    //region < Unused callback methods >

    override fun onActivityPaused(activity: Activity) = Unit
    override fun onActivityResumed(activity: Activity) = Unit
    override fun onActivityStarted(activity: Activity) = Unit
    override fun onActivityDestroyed(activity: Activity) = Unit
    override fun onActivitySaveInstanceState(activity: Activity, outState: Bundle?) = Unit

    //endregion

    /**
     * Map of components that survive a configuration change.
     */
    private val screenComponents: MutableMap<Class<out Activity>, ProvidesActivityInjectorFactories> = HashMap()

    override fun onActivityStopped(activity: Activity) {
        if (activity.isFinishing) {
            // remove finished activity component
            screenComponents.remove(activity.javaClass)
        }
    }

    override fun onActivityCreated(activity: Activity, savedInstanceState: Bundle?) {
        val screenComponent: ProvidesActivityInjectorFactories = screenComponents[activity.javaClass]
                ?: injectorFactories[activity.javaClass]!!.get().build().also {
                    screenComponents[activity.javaClass] = it
                }

        @Suppress("UNCHECKED_CAST")
        val activityInjectorFactory: AndroidInjector.Factory<Activity> = (screenComponent.provideInjectors()[activity.javaClass] as AndroidInjector.Factory<Activity>)

        activityInjectorFactory.create(activity).inject(activity)
    }

}

MainActivity.kt

@PerScreen
class ScreenRandom @Inject constructor() {
    val random = Random().nextInt()
}


@PerActivity
class ActivityRandom @Inject constructor() {
    val random = Random().nextInt()
}

class MainActivity : AppCompatActivity() {

    @Inject
    lateinit var screenRandom: ScreenRandom
    @Inject
    lateinit var activityRandom: ActivityRandom

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        setContentView(R.layout.activity_main)

        label.text = "This screens random number is:\n${screenRandom.random}\n\nThis activities random number is:\n${activityRandom.random}"

    }
}

MainScreenComponent.kt

@Module(subcomponents = [MainScreenSubComponent::class])
interface ScreenModule {

    @Multibinds
    fun screenInjectorFactories(): Map<Class<out Activity>, ProvidesActivityInjectorFactories.Builder>

    @Binds
    @IntoMap
    @ActivityKey(MainActivity::class)
    fun bindMainScreenSubComponent(builder: MainScreenSubComponent.Builder): ProvidesActivityInjectorFactories.Builder

}

interface ProvidesActivityInjectorFactories {
    fun provideInjectors(): Map<Class<out Activity>, AndroidInjector.Factory<out Activity>>

    interface Builder {
        fun build(): ProvidesActivityInjectorFactories
    }
}

@PerScreen
@Subcomponent(modules = [MainScreenModule::class])
interface MainScreenSubComponent : ProvidesActivityInjectorFactories {

    @Subcomponent.Builder
    abstract class Builder : ProvidesActivityInjectorFactories.Builder

}

@Module(subcomponents = [MainActivitySubComponent::class])
interface MainScreenModule {

    @Binds
    @IntoMap
    @ActivityKey(MainActivity::class)
    fun bindMainActivityInjectorFactory(builder: MainActivitySubComponent.Builder): AndroidInjector.Factory<out Activity>

}

@PerActivity
@Subcomponent
interface MainActivitySubComponent : AndroidInjector<MainActivity> {

    @Subcomponent.Builder
    abstract class Builder : AndroidInjector.Builder<MainActivity>()

}

PerActivity.kt

@Scope
@MustBeDocumented
@Retention(AnnotationRetention.RUNTIME)
annotation class PerActivity

PerScreen.kt

/**
 * Survives orientation change.
 */
@Scope
@MustBeDocumented
@Retention(AnnotationRetention.RUNTIME)
annotation class PerScreen