android - tutorial - ¿Cómo implementar Dagger para las clases de trabajadores?

how to use android jetpack

Question

Dado que el marco ( WorkerManager ) crea la clase Worker , ¿cómo podemos usar los campos @Inject en el Worker ?

Answer 1

Estoy usando these serie de publicaciones para implementar dagger en mi aplicación y ProfileManager es la clase que quiero inject en mi clase Worker .

UploadWorker

public class UploadWorker extends Worker {
@Inject
ProfileManager profileManager;
@Inject
@SuppressWarnings("WeakerAccess")
public UploadWorker(@NonNull Context context, @NonNull WorkerParameters workerParams) {
super(context, workerParams);
Provider.getAppComponent().inject(this);
}
@NonNull
@Override
public Result doWork() {
profileManager.someMethod();
}
}

En la clase de aplicación , estoy configurando Appcomponent en mi clase de Provider

 @Override
protected AndroidInjector<? extends DaggerApplication> applicationInjector() {
AppComponent appComponent = DaggerAppComponent.builder().application(this).build();
appComponent.inject(this);
Provider.setAppComponent(appComponent);
return appComponent;
}

Proveedor

public class Provider {
private static AppComponent appComponent;
public static AppComponent getAppComponent() {
return appComponent;
}
public static void setAppComponent(AppComponent component) {
appComponent = component;
}
}

Componente

@Singleton
@Component(modules = {
AndroidSupportInjectionModule.class,
ActivityBuilderModule.class,
ApiModule.class,
AppModule.class,
ViewModelModule.class
})
public interface AppComponent extends AndroidInjector<DaggerApplication> {
@Override
void inject(DaggerApplication instance);
void inject(MyApplication app);
void inject(UploadWorker uploadWorker);
@Component.Builder
interface Builder {
@BindsInstance
Builder application(Application application);
AppComponent build();
}
}

Answer 2

Tiene que proporcionar la clase utilizando @Provides anotación en el módulo para inyectar.

Primero crea un componente que contenga un módulo que proporcionará la clase.

@Component(modules = {Module.class})
public interface Component1{
void inject(SyncWorker syncWorker);
}

Clase de módulo

@Module
public class Module{
@Provides
public ISettingRepository getSettingRepo(){
return new ISettingRepository();
}
}

Ahora escriba su código, un constructor que se utiliza para inyectar el componente en su clase de trabajador.

public class SyncWorker extends Worker {
@Inject
ISettingRepository settingRepository;
public SyncWorker(){
DaggerComponent1.builder().build().inject();
}
@NonNull
@Override
public Result doWork() {
sync();
return Result.SUCCESS;
}
private void sync() {
}
}