How to do Assisted Injection with Navigation Compose?

Assisted Injection with Navigation Compose

Assisted injection is a powerful technique in Jetpack Compose that simplifies dependency injection for composable functions. It’s particularly useful when dealing with navigation, allowing you to pass dependencies directly to the destination composable without the need for complex arguments. This article explores the best practices for integrating assisted injection with Jetpack Compose’s Navigation component.

Understanding Assisted Injection

What is Assisted Injection?

Assisted injection is a variation of dependency injection where the dependencies are provided to a composable function during the construction phase. It leverages the composable’s constructor to receive the dependencies instead of passing them as parameters.

Why Use Assisted Injection?

• Simplified Parameter Handling: Eliminates the need to pass multiple dependencies as arguments to composables.
• Clearer Code: Makes composable functions more readable and maintainable.
• Improved Testability: Easier to mock dependencies during unit testing.

Implementation with Navigation Compose

Let’s see how to implement assisted injection within the context of Jetpack Compose’s Navigation component.

1. Defining a Composable with Assisted Injection

@Composable
fun UserDetailScreen(user: User) {
    // Use the 'user' object from the assisted injection
    Text("User Name: ${user.name}")
}

2. Using the AssistedInject annotation

@Composable
fun UserDetailScreen(user: User) {
    // Use the 'user' object from the assisted injection
    Text("User Name: ${user.name}")
}

@AssistedInject
constructor(user: User) {
    // Initialize the object using 'user' from the assisted injection
}

3. Defining the Navigation Graph

@Composable
fun NavigationGraph(navController: NavHostController) {
    NavHost(navController = navController, startDestination = "user_detail") {
        composable("user_detail") {
            val user = remember {
                // Inject user object
            }
            UserDetailScreen(user) 
        }
    }
}

Dependency Injection Framework

To enable assisted injection in your Navigation Compose project, you’ll need to use a dependency injection framework. Popular choices include:

Hilt

• Integration with Android’s Architecture Components: Hilt works seamlessly with ViewModels, Activities, and other Android components.
• Code Generation: Provides compile-time verification for your dependency injection setup.
• Simplified Setup: Reduces boilerplate code for dependency injection.

Koin

• Lightweight: Offers minimal overhead, making it a good choice for smaller projects.
• Flexibility: Allows for more customization in your dependency injection configuration.
• Easy Learning Curve: Simple and intuitive to use.

Example

This example demonstrates assisted injection using Hilt.

1. Add Hilt to the Project

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

2. Annotate your Application with `@HiltAndroidApp`

@HiltAndroidApp
class MyApplication: Application()

3. Use `@AssistedInject` in Your Composable

@AssistedInject
constructor(user: User) {
    // Initialize using the provided 'user' instance
}

4. Inject the dependency using `@EntryPoint`

@EntryPoint
@InstallIn(ActivityComponent::class)
interface UserEntryPoint {
    fun getUser(): User
}

5. Use the `UserEntryPoint` to retrieve the `User` object in your navigation graph

@Composable
fun NavigationGraph(navController: NavHostController) {
    NavHost(navController = navController, startDestination = "user_detail") {
        composable("user_detail") {
            val userEntryPoint = hiltEntryPoint(this) 
            val user = userEntryPoint.getUser()
            UserDetailScreen(user) 
        }
    }
}

Conclusion

Assisted injection offers a valuable approach for simplifying dependency injection in Jetpack Compose, particularly within navigation scenarios. By leveraging dependency injection frameworks like Hilt, you can streamline your composables, enhancing code clarity and maintainability. Employing assisted injection empowers you to develop well-structured and easily testable Android applications using Navigation Compose.