What is Dagger used for in Android development?

Dagger is used for dependency injection (Dependency Injection - DI) in Android applications.

Main advantages of using Dagger:

• Decoupling: Separates object creation from their usage, making the code more modular and easier to test.
• Improved testability: Allows easy mocking or stubbing when testing individual components.
• Object lifecycle management: Dagger can manage creation and reuse of objects (e.g., using annotations like @Singleton, @Reusable, @ActivityScoped, etc., for Dagger Android).
• More explicit dependency graph: Dagger generates code that clearly shows how components depend on each other.
• Higher runtime performance compared to reflection-based DI frameworks: Dagger generates code at compile time, avoiding reflection overhead.

Key concepts in Dagger:

• Modules (@Module): Provide dependencies. Methods annotated with @Provides specify how to create an instance of a dependency.
• Components (@Component, @Subcomponent): Connect modules and classes requesting dependencies. Components provide methods to obtain injected dependencies.
• @Inject: Used to annotate constructors, fields, or methods where Dagger should inject dependencies.
• Scope annotations (@Scope): Allow controlling the lifecycle of objects created by Dagger.

Example of dependency injection via constructor:

// Class that requires a dependency
public class MyPresenter {

    private final MyRepository repository;

    @Inject // Dagger will use this constructor
    public MyPresenter(MyRepository repository) {
        this.repository = repository;
    }

    // ...
}

// Dependency
public class MyRepository {
    // ...
}

// Module providing MyRepository
@Module
public class AppModule {

    @Provides
    public MyRepository provideMyRepository() {
        return new MyRepository();
    }
}

// Component
@Component(modules = AppModule.class)
public interface AppComponent {
    void inject(MyActivity activity); // Method for injection into Activity
}

In summary, Dagger helps create more structured, testable, and maintainable Android applications.