Are you familiar with using Dagger in Android…

Yes, I am familiar. Dagger is a dependency injection (DI) framework for Java and Android that is compiled at build time and allows creating optimized, high-performance, and easily testable code.

The main concepts include:

Modules: Provide dependencies. Annotated with @Module. Inside a module, methods with @Provides describe how to create a specific dependency.

@Module
public class AppModule {

    @Provides
    // provides application context
    Context provideAppContext(Application application) {
        return application.getApplicationContext();
    }

    @Provides
    // provides SharedPreferences
    SharedPreferences provideSharedPreferences(Context context) {
        return context.getSharedPreferences("MyPrefs", Context.MODE_PRIVATE);
    }
}

Components: Connect modules and inject dependencies. Annotated with @Component. Components are "dependency graphs".

@Singleton
@Component(modules = {AppModule.class})
// application component
public interface AppComponent {

    // method for injection into MainActivity
    void inject(MainActivity activity);

    // method to get SharedPreferences from the graph
    SharedPreferences getSharedPreferences();
}

Injection: The process of injecting dependencies. Uses @Inject for fields or constructors.

public class MainActivity extends AppCompatActivity {

    @Inject
    // dependency that Dagger will inject
    SharedPreferences sharedPrefs;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        // Dagger generates code to create the component and perform injection
        ((MyApplication) getApplication()).getAppComponent().inject(this);

        // sharedPrefs is now available
        String value = sharedPrefs.getString("key", "default");
        Log.d("MainActivity", "Value from SharedPreferences: " + value);
    }
}

Scopes: Manage the lifecycle of dependencies. @Singleton for application-wide dependencies, custom annotations for narrower scopes (e.g., @PerActivity).
```
@Scope
@Retention(RetentionPolicy.RUNTIME)
// custom scope for activity
public @interface PerActivity {}
```

Dagger also supports subcomponents (@Subcomponent) for creating smaller, hierarchical dependency graphs, useful for modular applications or dependencies with short lifecycles (e.g., user sessions or specific screens).

Main advantages of using Dagger:

Performance: Code generation at compile time minimizes runtime overhead compared to reflection-based DI frameworks.
Verifiability: The compiler checks the dependency graph, catching errors at build time rather than at runtime.
Testability: Simplifies replacing real dependencies with mock objects during testing.
Readability and maintainability: Clearly describes component dependencies.

Are you familiar with using Dagger in Android application development?