Dagger ne peut pas trouver des membres injectables sur un module

J'utilise Dagger pour l'injection de dépendance dans un projet Android, et je peux compiler et construire l'application bien. Le graphique de l'objet semble être correct et fonctionnel, mais lorsque j'ajoute Dagger-Compiler comme une dépendance pour obtenir des erreurs au moment de la compilation, il présente des erreurs bizarres:

[ERROR] error: No binding for com.squareup.tape.TaskQueue<com.atami \ .mgodroid.io.NodeIndexTask> required by com.atami \ .mgodroid.ui.NodeIndexListFragment for com.atami.mgodroid \ .modules.OttoModule [ERROR] error: No binding for com.squareup.tape.TaskQueue<com.atami \ .mgodroid.io.NodeTask> required by com.atami \ .mgodroid.ui.NodeFragment for com.atami.mgodroid.modules.OttoModule [ERROR] error: No injectable members on com.squareup.otto.Bus. Do you want to add an injectable constructor? required by com.atami. \ mgodroid.io.NodeIndexTaskService for com.atami.mgodroid.modules.TaskQueueModule 

L'erreur d'Otto ressemble à celle que Eric Burke mentionne dans son application Android Anatomy sur l'absence d'une annotation @Provides , mais comme vous pouvez le voir ci-dessous, je l'ai fait.

Mes modules Otto et TaskQueue sont les suivants:

 @Module( entryPoints = { MGoBlogActivity.class, NodeIndexListFragment.class, NodeFragment.class, NodeActivity.class, NodeCommentFragment.class, NodeIndexTaskService.class, NodeTaskService.class } ) public class OttoModule { @Provides @Singleton Bus provideBus() { return new AsyncBus(); } /** * Otto EventBus that posts all events on the Android main thread */ private class AsyncBus extends Bus { private final Handler mainThread = new Handler(Looper.getMainLooper()); @Override public void post(final Object event) { mainThread.post(new Runnable() { @Override public void run() { AsyncBus.super.post(event); } }); } } } 

 @Module( entryPoints = { NodeIndexListFragment.class, NodeFragment.class, NodeIndexTaskService.class, NodeTaskService.class } ) public class TaskQueueModule { private final Context appContext; public TaskQueueModule(Context appContext) { this.appContext = appContext; } public static class IOTaskInjector<T extends Task> implements TaskInjector<T> { Context context; /** * Injects Dagger dependencies into Tasks added to TaskQueues * * @param context the application Context */ public IOTaskInjector(Context context) { this.context = context; } @Override public void injectMembers(T task) { ((MGoBlogApplication) context.getApplicationContext()) .objectGraph().inject(task); } } public static class ServiceStarter<T extends Task> implements ObjectQueue.Listener<T> { Context context; Class<? extends Service> service; /** * Starts the provided service when a Task is added to the queue * * @param context the application Context * @param service the Service to start */ public ServiceStarter(Context context, Class<? extends Service> service) { this.context = context; this.service = service; } @Override public void onAdd(ObjectQueue<T> queue, T entry) { context.startService(new Intent(context, service)); } @Override public void onRemove(ObjectQueue<T> queue) { } } @Provides @Singleton TaskQueue<NodeIndexTask> provideNodeIndexTaskQueue() { ObjectQueue<NodeIndexTask> delegate = new InMemoryObjectQueue<NodeIndexTask>(); TaskQueue<NodeIndexTask> queue = new TaskQueue<NodeIndexTask>( delegate, new IOTaskInjector<NodeIndexTask>(appContext)); queue.setListener(new ServiceStarter<NodeIndexTask>( appContext, NodeIndexTaskService.class)); return queue; } @Provides @Singleton TaskQueue<NodeTask> provideNodeTaskQueue() { ObjectQueue<NodeTask> delegate = new InMemoryObjectQueue<NodeTask>(); TaskQueue<NodeTask> queue = new TaskQueue<NodeTask>( delegate, new IOTaskInjector<NodeTask>(appContext)); queue.setListener(new ServiceStarter<NodeTask>( appContext, NodeTaskService.class)); return queue; } } 

 /** * Module that includes all of the app's modules. Used by Dagger * for compile time validation of injections and modules. */ @Module( includes = { MGoBlogAPIModule.class, OttoModule.class, TaskQueueModule.class } ) public class MGoBlogAppModule { } 

One Solution collect form web for “Dagger ne peut pas trouver des membres injectables sur un module”

L'analyse complète du graphique de Dagger fonctionne à partir d'un module complet. C'est-à-dire @Module (complet = vrai), qui est par défaut. Parce que c'est par défaut, dagger, par défaut, supposera que toutes les liaisons sont disponibles à partir de ce module ou de ces modules qu'il inclut explicitement.

Dans ce cas, vous avez donné deux modules que vous réclamez sont complets, mais Dagger n'a aucun moyen de les lier ensemble au moment de la compilation sans un signal supplémentaire. En bref, sans OttoModule à propos de TaskQueueModule, le compilateur tentera d'analyser OttoModule pour sa totalité, et échouera, car il ne concerne pas actuellement TaskQueueModule.

Modifier l'annotation d'OttoModule en tant que telle:

 @Module( includes = TaskQueueModule.class, entryPoints = { MGoBlogActivity.class, NodeFragment.class, NodeActivity.class, NodeCommentFragment.class, NodeIndexTaskService.class, NodeTaskService.class } ) 

Et alors Dagger saura que pour que OttoModule soit complet, il inclut l'autre module dans sa définition complète.

Remarque: dagger-compilator ne peut pas détecter que TaskQueueModule existe sur le chemin de la classe et il suffit de savoir que le développeur a l'intention d'être utilisé avec OttoModule sans ce signal supplémentaire. Par exemple, vous pourriez avoir plusieurs modules qui définissent les files d'attente des tâches et à quel choix choisir? La déclaration doit être explicite.

coAndroid est un fan Android de Google, tout sur les téléphones Android, Android Wear, Android Dev et Android Games Apps.