How does Dagger 2 work internally in Android SDK?

Dagger 2 is a popular dependency injection framework for Android that helps manage and provide dependencies throughout your application. It uses compile-time code generation to create the dependency graph. This means that, instead of performing reflection at runtime to resolve dependencies, Dagger 2 creates classes that match your component structure, which leads to better performance compared to reflection-based approaches.

How Dagger 2 Works Internally

When you use Dagger 2 in your Android application, you typically follow these steps:

1. Define your dependencies: Use annotations like @Inject to indicate where dependencies should be injected.
2. Create modules: Use @Module and @Provides annotations to specify the classes that provide dependencies.
3. Set up components: Use @Component to define the connection between the modules and the classes requiring dependencies.
4. Inject dependencies: Use the generated component to inject the necessary dependencies into your classes during runtime.

Example of Dagger 2 Integration

import dagger.Component;
import dagger.Module;
import dagger.Provides;

@Module
class NetworkModule {
    @Provides
    fun provideRetrofit(): Retrofit {
        return Retrofit.Builder()
            .baseUrl("https://api.example.com")
            .build()
    }
}

@Component(modules = [NetworkModule::class])
interface AppComponent {
    fun inject(activity: MainActivity)
}

class MainActivity : AppCompatActivity() {
    @Inject
    lateinit var retrofit: Retrofit

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        DaggerAppComponent.create().inject(this) // Injecting dependencies
    }
}