🤖 Android Dependency Injection

A Beginner's Guide to Building Better Android Apps

Understanding DI concepts, benefits, and practical implementation

Press → to continue

🤔 What is Dependency Injection?

💡Dependency Injection (DI) is a design pattern that provides dependencies to an object instead of the object creating them itself.

Simple Analogy:

Think of it like ordering food at a restaurant:

Without DI: You go to the kitchen and cook your own meal
With DI: The waiter brings you the meal (dependency is injected)

                The object receives its dependencies from an external source rather than creating them internally.
            

🎯 Why Do We Need Dependency Injection?

❌ Problems Without DI

Hard to test
Tight coupling
Code duplication
Difficult maintenance

✅ Benefits With DI

Easy testing
Loose coupling
Code reusability
Better maintainability

🚀DI makes your Android apps more modular, testable, and maintainable!

❌ Bad Example: Without Dependency Injection

class UserRepository {
    private DatabaseHelper dbHelper;
    private NetworkService networkService;
    
    public UserRepository() {
        // Creating dependencies inside the class
        dbHelper = new DatabaseHelper();
        networkService = new NetworkService();
    }
    
    public User getUser(int id) {
        // Implementation using dbHelper and networkService
        return networkService.fetchUser(id);
    }
}

Problems with this approach:

🔗Tight coupling between classes
🧪Hard to test (can't mock dependencies)
⚙️Difficult to change implementations

✅ Good Example: With Dependency Injection

class UserRepository {
    private DatabaseHelper dbHelper;
    private NetworkService networkService;
    
    // Dependencies are injected via constructor
    public UserRepository(DatabaseHelper dbHelper, 
                         NetworkService networkService) {
        this.dbHelper = dbHelper;
        this.networkService = networkService;
    }
    
    public User getUser(int id) {
        return networkService.fetchUser(id);
    }
}

Benefits of this approach:

🔄Loose coupling
✨Easy to test with mocks
🔧Flexible implementations

🔧 Types of Dependency Injection

1. Constructor Injection

public UserService(UserRepository repository) {
    this.repository = repository;
}
            

2. Setter Injection

public void setUserRepository(UserRepository repository) {
    this.repository = repository;
}
            

3. Field Injection

@Inject
UserRepository repository;
            

💡Constructor injection is preferred because it ensures dependencies are available when the object is created.

🛠️ Popular Android DI Frameworks

Framework	Complexity	Performance	Best For
Dagger 2	High	Excellent	Large apps
Hilt	Medium	Excellent	Most Android apps
Koin	Low	Good	Kotlin projects

🎯Hilt is Google's recommended solution for dependency injection in Android.

⚡ Introduction to Hilt

🏗️Hilt is built on top of Dagger 2 and provides a simpler way to implement DI in Android apps.

Key Benefits of Hilt:

Reduces boilerplate code
Built-in Android components support
Compile-time verification
Easy testing

Setup (build.gradle):

dependencies {
    implementation "com.google.dagger:hilt-android:2.44"
    kapt "com.google.dagger:hilt-compiler:2.44"
}

📱 Step 1: Hilt Application Class

First, annotate your Application class with @HiltAndroidApp:

@HiltAndroidApp
class MyApplication : Application() {
    // Application logic here
}

And don't forget to register it in AndroidManifest.xml:

<application
    android:name=".MyApplication"
    android:label="@string/app_name"
    android:theme="@style/AppTheme">
    ...
</application>
            

💡This triggers Hilt's code generation and sets up the DI container.

🏭 Step 2: Creating Dependencies with @Module

Create a module to provide dependencies:

@Module
@InstallIn(SingletonComponent::class)
object NetworkModule {
    
    @Provides
    @Singleton
    fun provideRetrofit(): Retrofit {
        return Retrofit.Builder()
            .baseUrl("https://api.example.com/")
            .addConverterFactory(GsonConverterFactory.create())
            .build()
    }
    
    @Provides
    fun provideApiService(retrofit: Retrofit): ApiService {
        return retrofit.create(ApiService::class.java)
    }
}

🔧@InstallIn specifies which component should contain the module.

🎬 Step 3: Injecting into Activities

@AndroidEntryPoint
class MainActivity : AppCompatActivity() {
    
    @Inject
    lateinit var userRepository: UserRepository
    
    @Inject
    lateinit var apiService: ApiService
    
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        
        // Use injected dependencies
        loadUserData()
    }
    
    private fun loadUserData() {
        // userRepository and apiService are ready to use!
    }
}

✨@AndroidEntryPoint enables DI for Android components.

🏛️ Step 4: Injecting into ViewModels

@HiltViewModel
class UserViewModel @Inject constructor(
    private val userRepository: UserRepository
) : ViewModel() {
    
    private val _users = MutableLiveData<List<User>>()
    val users: LiveData<List<User>> = _users
    
    fun loadUsers() {
        viewModelScope.launch {
            val userList = userRepository.getUsers()
            _users.value = userList
        }
    }
}

In your Activity/Fragment:

@AndroidEntryPoint
class MainActivity : AppCompatActivity() {
    
    private val viewModel: UserViewModel by viewModels()
    
    // ViewModel with dependencies is automatically created!
}
            

🔨 Constructor Injection Example

For classes you own, use @Inject on the constructor:

class UserRepository @Inject constructor(
    private val apiService: ApiService,
    private val userDao: UserDao
) {
    
    suspend fun getUsers(): List<User> {
        return try {
            val remoteUsers = apiService.getUsers()
            userDao.insertUsers(remoteUsers)
            remoteUsers
        } catch (e: Exception) {
            userDao.getAllUsers()
        }
    }
    
    suspend fun getUserById(id: Int): User? {
        return userDao.getUserById(id)
    }
}

⚡Hilt automatically knows how to create this class and inject its dependencies!

🎯 Understanding Scopes

Scopes control the lifetime of dependencies:

Scope	Lifetime	Use Case
`@Singleton`	App lifetime	Database, Network clients
`@ActivityScoped`	Activity lifetime	Activity-specific services
`@FragmentScoped`	Fragment lifetime	Fragment-specific data

@Provides
@Singleton
fun provideDatabase(): AppDatabase {
    // This will be created only once
}
            

🧪 Testing with Dependency Injection

DI makes testing much easier by allowing mock dependencies:

@HiltAndroidTest
class UserRepositoryTest {
    
    @get:Rule
    var hiltRule = HiltAndroidRule(this)
    
    @Inject
    lateinit var userRepository: UserRepository
    
    @Before
    fun setup() {
        hiltRule.inject()
    }
    
    @Test
    fun testGetUsers() {
        // Test your repository with injected dependencies
        val users = userRepository.getUsers()
        assertNotNull(users)
    }
}

🎭You can easily replace real dependencies with test doubles using @TestInstallIn.

⭐ Best Practices

DO:

✅Use constructor injection when possible
✅Keep modules focused and cohesive
✅Use appropriate scopes
✅Write tests for your dependencies

DON'T:

❌Over-inject (inject only what you need)
❌Create circular dependencies
❌Use field injection unnecessarily
❌Ignore compile-time errors

Remember: DI should make your code simpler, not more complex!

🌍 Real-world Example: Complete Setup

Here's how all pieces fit together:

// 1. Application Class
@HiltAndroidApp
class MyApp : Application()

// 2. Module
@Module
@InstallIn(SingletonComponent::class)
object AppModule {
    @Provides @Singleton
    fun provideUserRepo(api: ApiService) = UserRepository(api)
}

// 3. Activity
@AndroidEntryPoint
class MainActivity : AppCompatActivity() {
    private val viewModel: UserViewModel by viewModels()
}

// 4. ViewModel
@HiltViewModel
class UserViewModel @Inject constructor(
    private val repository: UserRepository
) : ViewModel()

⚠️ Common Mistakes to Avoid

❌ Common Mistakes

Forgetting @AndroidEntryPoint
Wrong component in @InstallIn
Creating circular dependencies
Not handling nullable dependencies

✅ Solutions

Always annotate entry points
Choose appropriate components
Design dependencies carefully
Use proper nullability annotations

💡Most errors are caught at compile-time, making debugging easier!

⚡ Performance Considerations

Hilt Performance Benefits:

🚀Compile-time code generation (no reflection)
💾Efficient object creation and reuse
🎯Proper scoping reduces memory usage

Tips for Better Performance:

Use @Singleton for expensive objects
Lazy initialization when appropriate
Avoid injecting heavy objects into activities

@Provides
@Singleton
fun provideExpensiveService(): ExpensiveService {
    return ExpensiveService() // Created only once
}

🎉 Conclusion

What We've Learned:

🧠Dependency Injection concepts and benefits
🛠️How to set up Hilt in Android projects
💉Different types of injection
🏗️Creating modules and providing dependencies
🧪Testing with DI

🚀 Next Steps:

Start implementing DI in your Android projects! Begin with simple dependencies and gradually adopt more advanced features.

💻Happy Coding with Dependency Injection!