dagger

Interface Summary
Interface Description

Lazy<T>
A handle to a lazily-computed value.

MembersInjector<T>
Injects dependencies into the fields and methods on instances of type T.

Interface Summary
Interface	Description
Lazy<T>	A handle to a lazily-computed value.
MembersInjector<T>	Injects dependencies into the fields and methods on instances of type `T`.

Annotation Types Summary
Annotation Type	Description
Binds	Annotates abstract methods of a `Module` that delegate bindings.
BindsInstance	Marks a method on a component builder or subcomponent builder that allows an instance to be bound to some type within the component.
BindsOptionalOf	Annotates methods that declare bindings for `Optional` containers of values from bindings that may or may not be present in the component.
Component	Annotates an interface or abstract class for which a fully-formed, dependency-injected implementation is to be generated from a set of Component.modules().
Component.Builder	A builder for a component.
MapKey	Identifies annotation types that are used to associate keys with values returned by provider methods in order to compose a map.
Module	Annotates a class that contributes to the object graph.
Provides	Annotates methods of a module to create a provider method binding.
Reusable	A scope that indicates that the object returned by a binding may be (but might not be) reused.
Subcomponent	A subcomponent that inherits the bindings from a parent `Component` or `Subcomponent`.
Subcomponent.Builder	A builder for a subcomponent.

Package dagger Description

This package contains the public API for the Dagger 2 dependency injection framework. By building upon JSR 330, Dagger 2 provides an annotation-driven API for dependency injection whose implementation is entirely generated at compile time by annotation processors.

The entry point into the API is the Component, which annotates abstract types for Dagger 2 to implement. The dependency graph is configured using annotations such as Module, Provides and Inject.

dagger.internal.codegen.ComponentProcessor is the processor responsible for generating the implementation. Dagger uses the annotation procesor service loader to automatically configure the processor, so explict build configuration shouldn't be necessary.