2020/06更新
使用Hilt和Hilt for Jetpack会使事情变得更加容易。
使用Hilt，你只需要：
- 在您的Application类上添加注释
@HiltAndroidApp
- 在应用程序类的字段中注入现成的
HiltWorkerFactory
- 实现接口
Configuration.Provider并在步骤2中返回注入的工作工厂
现在，将Worker构造函数上的注释从@Inject更改为@WorkerInject
class ExampleWorker @WorkerInject constructor(
@Assisted appContext: Context,
@Assisted workerParams: WorkerParameters,
someDependency: SomeDependency // your own dependency
) : Worker(appContext, workerParams) { ... }
就是这样了！
(另外，不要忘记禁用默认的工作管理器初始化)
===========
旧解决方案
从版本1.0.0-beta01开始，这里提供了使用WorkerFactory进行Dagger注入的实现。
这个概念来自于这篇文章：https://medium.com/@nlg.tuan.kiet/bb9f474bde37，我只是逐步发布了自己的实现（使用Kotlin）。
===========
这个实现的目的是：
每次您想要向工作者添加依赖项时，都将依赖项放在相关的工作者类中
===========
1. 为所有工作者的工厂添加接口
IWorkerFactory.kt
interface IWorkerFactory<T : ListenableWorker> {
fun create(params: WorkerParameters): T
}
2. 添加一个简单的工人类和工厂，它实现了IWorkerFactory接口并具有此工作程序的依赖项
HelloWorker.kt
class HelloWorker(
context: Context,
params: WorkerParameters,
private val apiService: ApiService
): Worker(context, params) {
override fun doWork(): Result {
Log.d("HelloWorker", "doWork - fetchSomething")
return apiService.fetchSomething()
.map { Result.success() }
.onErrorReturnItem(Result.failure())
.blockingGet()
}
class Factory @Inject constructor(
private val context: Provider<Context>,
private val apiService: Provider<ApiService>
) : IWorkerFactory<HelloWorker> {
override fun create(params: WorkerParameters): HelloWorker {
return HelloWorker(context.get(), params, apiService.get())
}
}
}
3. 为Dagger的多绑定添加一个WorkerKey
WorkerKey.kt
@MapKey
@Target(AnnotationTarget.FUNCTION)
@Retention(AnnotationRetention.RUNTIME)
annotation class WorkerKey(val value: KClass<out ListenableWorker>)
4. 添加一个Dagger模块，用于多绑定worker（实际上是多绑定工厂）。
WorkerModule.kt
@Module
interface WorkerModule {
@Binds
@IntoMap
@WorkerKey(HelloWorker::class)
fun bindHelloWorker(factory: HelloWorker.Factory): IWorkerFactory<out ListenableWorker>
// every time you add a worker, add a binding here
}
5. 将WorkerModule放入AppComponent中。我在这里使用dagger-android来构建组件类。
AppComponent.kt
@Singleton
@Component(modules = [
AndroidSupportInjectionModule::class,
NetworkModule::class, // provides ApiService
AppModule::class, // provides context of application
WorkerModule::class // <- add WorkerModule here
])
interface AppComponent: AndroidInjector<App> {
@Component.Builder
abstract class Builder: AndroidInjector.Builder<App>()
}
6. 在1.0.0-alpha09版本发布后，添加自定义WorkerFactory以利用创建worker的能力。
DaggerAwareWorkerFactory.kt
class DaggerAwareWorkerFactory @Inject constructor(
private val workerFactoryMap: Map<Class<out ListenableWorker>, @JvmSuppressWildcards Provider<IWorkerFactory<out ListenableWorker>>>
) : WorkerFactory() {
override fun createWorker(
appContext: Context,
workerClassName: String,
workerParameters: WorkerParameters
): ListenableWorker? {
val entry = workerFactoryMap.entries.find { Class.forName(workerClassName).isAssignableFrom(it.key) }
val factory = entry?.value
?: throw IllegalArgumentException("could not find worker: $workerClassName")
return factory.get().create(workerParameters)
}
}
7. 在 Application 类中，用我们自定义的工厂替换 WorkerFactory：
App.kt
class App: DaggerApplication() {
override fun onCreate() {
super.onCreate()
configureWorkManager()
}
override fun applicationInjector(): AndroidInjector<out DaggerApplication> {
return DaggerAppComponent.builder().create(this)
}
@Inject lateinit var daggerAwareWorkerFactory: DaggerAwareWorkerFactory
private fun configureWorkManager() {
val config = Configuration.Builder()
.setWorkerFactory(daggerAwareWorkerFactory)
.build()
WorkManager.initialize(this, config)
}
}
8. 不要忘记禁用默认的工作管理器初始化
AndroidManifest.xml
<provider
android:name="androidx.work.impl.WorkManagerInitializer"
android:authorities="${applicationId}.workmanager-init"
android:enabled="false"
android:exported="false"
tools:replace="android:authorities" />
就是这样。
每当您想要为工作者添加依赖项时，您将依赖项放在相关的工作者类中（例如此处的HelloWorker）。
每当您想要添加工作者时，请在工作者类中实现工厂，并将工作者的工厂添加到WorkerModule进行多重绑定。
如需更多详细信息，例如使用AssistedInject来减少样板代码，请参阅我在文章开头提到的文章。
