Migrating from Dagger Hilt to Koin: Android

In modern Android development, Dependency Injection (DI) plays a crucial role in creating modular, testable, and scalable applications. While Dagger Hilt has been a popular choice for DI, Koin offers a more straightforward and Kotlin-friendly approach. In this article, we’ll guide you through how to migrate your project from Dagger Hilt to Koin, compare their core differences, explore Koin’s advantages, and provide comprehensive examples for different use cases including testing, activities, fragments, and Jetpack Compose.

Setting Up Koin: Replacing Dagger Hilt

The first step in transitioning to Koin is to remove Dagger Hilt dependencies from your Gradle files. Replace them with the Koin dependencies as follows:

// Replace Hilt dependencies with the following Koin dependencies
implementation "io.insert-koin:koin-androidx-compose:3.5.3"
implementation "io.insert-koin:koin-android:3.5.3"
implementation "io.insert-koin:koin-androidx-navigation:3.5.3"

After updating your dependencies, sync your Gradle files. Now you’re ready to set up Koin and start defining your modules. If you’re exploring advanced navigation techniques, be sure to check out this guide on Jetpack Compose navigation.

Defining Modules: How Koin Manages Dependencies

In Dagger Hilt, dependencies are defined in classes annotated with @Module. For example, setting up a **Retrofit** instance in Hilt might look like this:

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

    @Provides
    fun provideApiService(retrofit: Retrofit): ApiService {
        return retrofit.create(ApiService::class.java)
    }
}

This approach requires multiple annotations and build-time code generation. On the other hand, Koin simplifies dependency definitions using a Kotlin **DSL**:

val appModule = module {
    single { Retrofit.Builder()
        .baseUrl("https://example.com")
        .addConverterFactory(GsonConverterFactory.create())
        .build()
    }

    single { get<Retrofit>().create(ApiService::class.java) }
}

The single function in Koin declares a Singleton instance, and the get() function resolves the required dependency without additional annotations. This provides a clear and concise way to manage your DI.

Advantages of Koin Over Dagger Hilt

• Runtime Dependency Resolution: Unlike Dagger Hilt, which resolves dependencies at compile-time, Koin resolves dependencies at runtime. This dynamic nature offers flexibility, though it requires careful attention to runtime errors. (See **Koin Documentation**)
• No Code Generation: Since Koin is built on Kotlin’s DSL, it does not rely on code generation and reflection, resulting in faster build times and easier readability.
• Simplified Syntax: With Koin, you can avoid complex annotations and scopes. The API is intuitive and minimizes boilerplate code, making it developer-friendly. For more on simplifying your Kotlin code, explore this article on Kotlin Coroutines and concurrency.

Using Koin with the Application Class

Unlike Dagger Hilt, which uses automated setup, Koin requires manual initialization in the Application class. Here’s how you do it:

class MyApplication : Application() {
    override fun onCreate() {
        super.onCreate()
        startKoin {
            androidContext(this@MyApplication)
            modules(appModule)
        }
    }
}

startKoin initializes Koin, and androidContext sets the application context. By providing the modules function, you attach the necessary modules to your app. This simple approach gives you more control over how and when your DI setup is initialized.

Injecting ViewModels with Koin

When it comes to injecting ViewModels, Koin’s process is simple and integrates seamlessly with Jetpack Compose and other components. Let’s compare this with Dagger Hilt:

Dagger Hilt Example

@HiltViewModel
class MyViewModel @Inject constructor(
    private val repository: Repository
) : ViewModel() {
    // ViewModel implementation
}

And how you would use it in a Fragment:

@AndroidEntryPoint
class MyFragment : Fragment() {
    private val viewModel: MyViewModel by viewModels()
}

Koin Example

class MyViewModel(private val repository: Repository) : ViewModel() {
    // ViewModel implementation
}

val viewModelModule = module {
    viewModel { MyViewModel(get()) }
}

And injecting the ViewModel in Jetpack Compose:

@Composable
fun MyScreen(viewModel: MyViewModel = get()) {
    // Compose UI logic
}

The viewModel function in Koin makes ViewModel injection lifecycle-aware, and its simple syntax enhances readability and integration across activities, fragments, and Compose.

Testing with Koin: A Comprehensive Example

Koin offers powerful testing capabilities, allowing you to swap real dependencies with mocks or fakes. Here’s an example:

// Define a test module
val testModule = module {
    single { mock<ApiService>() }
    single { FakeRepository(get()) } // Injecting a fake repository
}

class MyViewModelTest {
    private lateinit var viewModel: MyViewModel

    @Before
    fun setup() {
        startKoin {
            modules(testModule)
        }
        viewModel = MyViewModel(get()) // Retrieve ViewModel from Koin
    }

    @Test
    fun testViewModelFunction() {
        // Test logic for verifying ViewModel behavior
        assertEquals("Expected Result", viewModel.someFunction())
    }

    @After
    fun teardown() {
        stopKoin() // Stop Koin after tests
    }
}

In this example, you can easily mock dependencies like ApiService and replace the Repository with a fake implementation. Use libraries like **Mockito** for creating mocks and stubs as needed.

Comparing Activity and Fragment Usage in Dagger Hilt and Koin

Let’s look at how activities and fragments differ when injecting dependencies with Dagger Hilt and Koin. In Hilt, you typically use annotations like @AndroidEntryPoint:

Dagger Hilt Usage

@AndroidEntryPoint
class MainActivity : AppCompatActivity() {
    @Inject lateinit var repository: Repository // Dependency injection
}

Koin Usage

class MainActivity : AppCompatActivity() {
    private val repository: Repository by inject() // Inject with Koin
}

With Koin, there’s no need for complex annotations or build-time code generation. You can simply use inject() to retrieve dependencies, enhancing readability and reducing boilerplate.

Conclusion: Koin vs. Dagger Hilt

Koin stands out as a simpler, more developer-friendly DI framework for Android. It leverages Kotlin’s DSL for intuitive syntax and avoids the complexity of annotations found in Dagger Hilt. However, Hilt still has its advantages for large-scale applications, such as compile-time safety and better performance.

Depending on your project’s needs, you can choose the right approach to streamline your dependency injection and improve your development workflow.