Wie zu injizieren in ein BroadcastReceiver

Könnte es zu spät sein, um diese Frage zu beantworten, aber ich werde ein Beispiel von meinem letzten Projekt, wo ich versuchte zu injizieren AppWidgetProvider die eine direkte Unterklasse von BroadcastReceiver.

Müssen wir injizieren eine retrofit-service in einem BroadcastReceiver:

@Module
public class NetModule {
    /** shrunk for simplicity's sake. **/
    @Singleton
    @Provides
    public WidgetService provideWidgetService(Application application, OkHttpClient client, Gson gson) {
        return new Retrofit.Builder()
                .addConverterFactory(GsonConverterFactory.create(gson))
                .baseUrl(application.getString(R.string.api_url))
                .client(client)
                .build()
                .create(WidgetService.class);
    }
}

Erstellen Sie eine abstrakte @Module für die mit abstrakten Methoden, annotiert mit @ContributesAndroidInjector zurückgeben BroadcastReceivers Sie wollen zu injizieren:

/**
 * To inject the app widgets.
 */
@Module
public abstract class WidgetsModule {
    @ContributesAndroidInjector
    abstract IngredientsWidget contributesIngredientsWidget();
}

Wenn Sie vergessen haben, fügen Sie dieses Modul erhalten Sie eine Fehlermeldung wie:

java.lang.IllegalArgumentException: No Injektor Fabrik gebunden für
Klasse<>

Dann die Komponente mit den beiden Modulen neben AndroidInjectionModule

@Singleton
@Component(modules = {AndroidInjectionModule.class, NetModule.class, WidgetsModule.class})
public interface AppComponent {
    void inject(RecipesApp recipesApp);
}

Dann in Ihre Application von Ihnen implementierte Klasse HasBroadcastReceiverInjector - Schnittstelle.

public class RecipesApp extends Application implements HasBroadcastReceiverInjector {

    @Inject
    DispatchingAndroidInjector<BroadcastReceiver> broadcastReceiverInjector;

    @Override
    public void onCreate() {
        super.onCreate();

        component().inject(this);
    }

    public AppComponent component() {
        return DaggerAppComponent.builder()
                .build();
    }

    @Override
    public AndroidInjector<BroadcastReceiver> broadcastReceiverInjector() {
        return broadcastReceiverInjector;
    }
}

Schließlich können Sie injizieren Ihre BroadcastReceiver innerhalb onReceive() vor dem Aufruf der super().

public class IngredientsWidget extends AppWidgetProvider {

    @Inject
    public WidgetService api;


    @Override
    public void onReceive(Context context, Intent intent) {
        /** Don't forget this line **/
        AndroidInjection.inject(this, context);
        super.onReceive(context, intent);
    }

}

Finden Sie mehr darüber, wie zu injizieren android-Komponenten docs.

Baute ich eine kleine Probe: broadcast-Injektion.

Habe ich es geschafft, um zu injizieren, use-cases, die in meine Sendung durch die Definition eines Moduls, die die Anwendungsfälle, die ich brauche, und ich füge das Modul auf der onReceive-Methode, überprüfen Sie den code unten:

Meine BroadcastReceiverModule:

@Module(injects = { MyBroadcastReceiver.class }, addsTo = MyAppModule.class)
public class BroadcastReceiverModule {
    @Provides @Singleton MyUtilsClass providesMyUtilsClass(MyUtilsClassImpl myUtilsClass) {
        return myUtilsClass;
    }
    @Provides @Singleton MyUseCase providesMyUseCase(MyUseCaseImpl myUseCaseUtils) {
        return myUseCaseUtils;
    }
}

Meine BroadCastReceiver:

@Inject MyUtilsClass myUtilsClass;
@Inject MyUseCase myUseCase;
@Override public void onReceive(Context context, Intent intent) {
    AcidApplication.getScopedGraph(getModules().toArray()).inject(this);
    myUseCase.call();
    myUtilsClass.doSomething();
}
protected List<Object> getModules() {
    List<Object> result = new ArrayList<>();
    result.add(new BroadcastReceiverModule());
    return result;
}