androidx workmanager injector temporary impl

AndroidWorkerInjection.kt

import androidx.work.Worker

object AndroidWorkerInjection {

    fun inject(worker: Worker) {
        checkNotNull(worker, { "worker" })
        val application = worker.applicationContext
        if (application !is HasWorkerInjector) {
            throw RuntimeException("${application.javaClass.canonicalName} does not implement ${HasWorkerInjector::class.java.canonicalName}")
        }

        val workerInjector = (application as HasWorkerInjector).workerInjector()
        checkNotNull(workerInjector, { "${application.javaClass}.workerInjector() return null" })
        workerInjector.inject(worker)
    }
}

AndroidWorkerInjectionModule.kt

import androidx.work.Worker
import dagger.Module
import dagger.android.AndroidInjector
import dagger.multibindings.Multibinds

@Module
abstract class AndroidWorkerInjectionModule {
    @Multibinds
    abstract fun workerInjectorFactories(): Map<Class<out Worker>, AndroidInjector.Factory<out Worker>>
}

AppComponent.kt

import dagger.Component
import dagger.android.AndroidInjectionModule
import dagger.android.AndroidInjector
import javax.inject.Singleton

@Singleton
@Component(modules = [
    // AppModule::class,
    // AndroidInjectionModule::class
    // And all other related modules
    AndroidWorkerInjectionModule::class
])
interface AppComponent : AndroidInjector<App> {
    @Component.Builder
    abstract class Builder : AndroidInjector.Builder<App>()
}

HasWorkerInjector.kt

import androidx.work.Worker
import dagger.android.AndroidInjector

interface HasWorkerInjector {
    fun workerInjector(): AndroidInjector<Worker>
}

MyWorker.kt

import androidx.work.Worker
import javax.inject.Inject

class MyWorker : Worker() {
    override fun doWork(): WorkerResult {
        AndroidWorkerInjection.inject(this)
        return WorkerResult.SUCCESS
    }
}

MyWorkerSubcomponent.kt

import dagger.Subcomponent
import dagger.android.AndroidInjector

@Subcomponent
interface MyWorkerSubcomponent : AndroidInjector<MyWorker> {
    @Subcomponent.Builder
    abstract class Builder : AndroidInjector.Builder<MyWorker>()
}

WorkerKey.kt

import androidx.work.Worker
import dagger.MapKey
import kotlin.reflect.KClass

@MapKey
@Retention(AnnotationRetention.RUNTIME)
@Target(AnnotationTarget.FUNCTION)
annotation class WorkerKey(val value: KClass<out Worker>)

WorkerModule.kt

import dagger.Binds
import dagger.Module
import dagger.android.AndroidInjector
import dagger.multibindings.IntoMap

@Module(subcomponents = [
    MyWorkerSubcomponent::class
])
abstract class WorkerModule {
    @Binds
    @IntoMap
    @WorkerKey(MyWorker::class)
    abstract fun bindMyWorkerFactory(builder: MyWorkerSubcomponent.Builder): AndroidInjector.Factory<out Worker>
}

Since the update from Work Manager and Dagger broke some things, please use this gist @luanmm made instead: https://gist.github.com/luanmm/85dd8217ed3f7384e6bab075a8ab7a61