I know from experience. When I first started developing Android apps, I thought it was easy to create objects manually.
But as the app grew, so did the mess. I had tight coupling, boilerplate code, and code that was harder to test than to write.

And then I stumbled upon Hilt. Game. Changer.

🧠 What is Hilt?

Hilt is a dependency injection library for Android built on top of Dagger.

It helps you manage how objects are created and shared across your app — without writing a lot of boilerplate code.

🤔 Why do we even need Hilt?

In a typical Android app, you often:

• Create objects manually (repositories, APIs, databases)
• Pass them through multiple layers
• Handle lifecycle yourself

As your app grows, this becomes:

• Hard to maintain ❌
• Hard to test ❌
• Easy to break ❌

🧩 Simple Analogy

Think of Hilt like a smart delivery system.

Instead of building and carrying objects everywhere, you simply:

“Ask for what you need”…and Hilt delivers it at the right time.

⚙️ Step 1: Adding Hilt to Your Project

In your project-level build.gradle:

plugins {
    alias(libs.plugins.android.application) apply false
    alias(libs.plugins.android.library) apply false
    alias(libs.plugins.kotlin.android) apply false
    alias(libs.plugins.kotlin.compose) apply false
    alias(libs.plugins.hilt) apply false
    alias(libs.plugins.ksp) apply false
}

In your app-level build.gradle:

plugins {
    alias(libs.plugins.android.application)
    alias(libs.plugins.kotlin.compose)
    alias(libs.plugins.hilt)
    alias(libs.plugins.ksp)
}

dependencies {
    implementation(libs.hilt.android)
    ksp(libs.hilt.compiler)
    implementation(libs.androidx.hilt.navigation.compose)
}

libs.versions.toml

[versions]
hilt = "2.59.2"
ksp = "2.0.21-1.0.27"

[libraries]
hilt-android = { module = "com.google.dagger:hilt-android", version.ref = "hilt" }
hilt-compiler = { module = "com.google.dagger:hilt-compiler", version.ref = "hilt" }

[plugins]
hilt = { id = "com.google.dagger.hilt.android", version.ref = "hilt" }
ksp = { id = "com.google.devtools.ksp", version.ref = "ksp" }

With the setup complete, the next step is to initialize Hilt in our application class, which acts as the entry point for dependency injection.

🧩 Step 2: Initialize Hilt in Application Class

@HiltAndroidApp
class MyApp : Application()

💡 Why this matters

• Initializes Hilt
• Creates the dependency graph
• Required entry point for injection

Don’t forget in AndroidManifest.xml:

<application
    android:name=".MyApp"
    ... >
</application>

🚪 Step 3: Enable Injection in Android Components

Now that Hilt is set up, we need to tell it where dependencies can be injected — like Activities, Fragments, etc.

📍 Add @AndroidEntryPoint to Your Activity

@AndroidEntryPoint
class MainActivity : AppCompatActivity() {
    // We’ll inject dependencies here next 👀
}

💡 What this does

• Enables dependency injection in Android components
• Connects Activity to Hilt

🧪 Step 4: Create Your First Dependency

class UserRepository @Inject constructor() {
fun getUserName(): String {
 return "Jane Doe"
 }
}

💡 What’s happening here?

The @Inject annotation tells Hilt: “Hey, you can create an instance of this class whenever it’s needed.”

• Hilt now knows how to construct UserRepository
• No need to manually create it using UserRepository()
• This works as long as all dependencies inside it are also known to Hilt

💉 Step 5: Injecting the Dependency

@AndroidEntryPoint
class MainActivity : AppCompatActivity() {

    @Inject lateinit var userRepository: UserRepository

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        println(userRepository.getUserName())
    }
}

💡 What’s happening here?

The @Inject keyword tells Hilt: “Give me an instance of UserRepository here.”

• No manual creation (UserRepository()) needed
• Hilt automatically provides the instance

🧠 Step 6: Using Hilt with ViewModel

In real-world Android apps, most of your logic lives inside ViewModels.
So let’s see how Hilt helps inject dependencies there cleanly.

@HiltViewModel
class MainViewModel @Inject constructor(
    private val userRepository: UserRepository
) : ViewModel() {

    fun getUserName(): String {
        return userRepository.getUserName()
    }
}

private val viewModel: MainViewModel by viewModels()

👉 No factory, no boilerplate — just clean injection.

🧩 Step 7: Using Modules (@Module, @Provides)

Use this when Hilt cannot create objects automatically.

@Module
@InstallIn(SingletonComponent::class)
object AppModule {

    @Provides
    fun provideUserRepository(): UserRepository {
        return UserRepository()
    }
}

🧠 When to use Modules?

• Retrofit
• Room Database
• Third-party libraries

🔁 Real-world example (Retrofit style)

@Provides
fun provideApiService(): ApiService {
    return Retrofit.Builder()
        .baseUrl("https://example.com")
        .build()
        .create(ApiService::class.java)
}

🚀 Final Thoughts

With Hilt in place, you’ve taken a big step toward building a clean and scalable Android architecture.

No more:

• Manual object creation
• Passing dependencies everywhere
• Confusing initialization logic

Hilt quietly handles all of it — so you can focus on building features, not wiring objects.

So let me start the journey I followed to guide you as well

STEP 1: Create Your Account

Go to platform.deepseek.com and click “Sign Up.” Use your email — takes 30 seconds.

Bonus: New accounts get 5 million free tokens automatically. Enough for thousands of test calls without spending anything.

STEP 2: Get Your API Key

Once logged in:

• Click on “API Keys” in the left menu
• Click “Create new API key”
• Give it a name (like “explain-app”)
• Copy the key immediately and save it somewhere safe

STEP 3: Created my android application (Basic)

I opened Android Studio and created a new project with an Empty Views Activity.

Using Jetpack Compose I created an sample input view.

STEP 4: Advanced DeepSeek Integration in Android

Now for the real magic — connecting our simple app to DeepSeek API. Here’s how I set it up:

Adding Dependencies

In app/build.gradle.kts:

Building the API Service

Creating the Repository

Connecting to MainActivity

API Call Structure

API Key Storage in local.properties

In local.properties (root level):

Important: Added local.properties to .gitignore so API keys never get committed!

Loading API Key in build.gradle.kts

Using the Key in Code

ADDITIONAL STEP: Making Your Integration Production-Ready

Error Handling — Try-catch blocks for network failures and API errors

Loading States — Progress indicator while waiting for response

Input Validation — Check for empty questions before calling API

Timeout Config — 30-second connect/read timeouts in OkHttp

API Key Security — Stored in BuildConfig, not hardcoded

User Feedback — Toast messages for errors and empty inputs

🔗 SEE IT IN ACTION

Before I explain why I chose DeepSeek over other models, here's the working app:

📱 GitHub Repository
https://github.com/yourusername/explain-like-im-10
(Fully open-source code for you to explore)

Why Deepseek and not others?

Before building my “Explain Like I’m 10” app, I compared every major AI model. OpenAI’s GPT-4.1 cost $0.0008 per explanation, Claude was $0.0025, and even Gemini ran $0.0009. But DeepSeek? Just $0.00012 per answer. At first I thought Llama 4 was even cheaper, but it required complicated self-hosting. Then I found the feature that broke the bank — in a good way. DeepSeek offers context caching: send the same system message repeatedly, and they remember it, giving you 90% off on those parts. For an app where every question starts with “Explain like I’m 10,” this meant my $2 would stretch so far it might never run out.

I had the thrilling chance to implement my mobile app with the Gemini AI to provide responses from Firebase Firestore data.

When I embarked on integrating Dialogflow and using its agent’s features, I could find a lot of resources for web applications but hardly any for mobile apps. Therefore, I had to conduct a lot of research and testing to get it done. I’m creating this blog to make it easier for fellow mobile developers.

First things first, we need to integrate our Firebase database and generate a service.json file for integration. Please follow the steps in this video to obtain the service.json file.
Here is the link to the video: Generate service account key in Google Cloud Platform (GCP).

While updating roles in that , make sure to add Dialogflow API Client and Service Account User.

Next, we need to create a Dialogflow CX agent, as demonstrated in the video, and configure it with the required data. This data will be passed as a file in Datastore to ensure proper communication between the agent and the application. You can follow the step-by-step process in this video: Datastore Integration — Google Dialogflow CX Generative AI.

Once these steps are completed, the focus shifts to the application side, where we integrate and configure the necessary components for seamless communication with Dialogflow CX.

Step 1: Add the necessary dependencies.

implementation("com.google.cloud:google-cloud-dialogflow-cx:0.28.0")
implementation ("io.grpc:grpc-okhttp:1.54.0")
implementation ("io.grpc:grpc-protobuf:1.54.0")
implementation ("io.grpc:grpc-stub:1.54.0")
implementation ("io.grpc:grpc-netty-shaded:1.54.0")

Step 2: Add the necessary details from the Dialogflow CX Console to your Constants object.

Step 3: Place the service.json file inside the assets folder of your application.

Note: This method is recommended for testing purposes only. For production-level applications, embedding the file directly in the app is not advised due to security concerns.

Step 4: Copy and implement the following piece of code to integrate Dialogflow into your Android application. This code will establish a connection between your app and the Dialogflow CX agent, enabling seamless interaction and response handling.

fun getMessage(context: Context, prompt: String): String {
    return try {
        // Retrieve Google authentication credentials from the service.json file
        val inputStream = context.assets.open("service.json")
        val credentials = GoogleCredentials.fromStream(inputStream)

        // Configure Dialogflow CX session settings with authentication credentials
        val settings = SessionsSettings.newBuilder()
            .setCredentialsProvider(FixedCredentialsProvider.create(credentials))
            .build()

        // Create a SessionsClient instance to communicate with Dialogflow CX
        val sessionsClient = SessionsClient.create(settings)

        // Generate a unique session ID for this conversation
        val sessionId = UUID.randomUUID().toString()

        // Define the session name using project-specific constants
        val session = SessionName.of(
            Constants.PROJECT_ID,  // Google Cloud project ID
            Constants.LOCATION,    // Region where the Dialogflow agent is deployed
            Constants.AGENT_ID,    // Unique ID of the Dialogflow CX agent
            sessionId              // Unique session ID for conversation tracking
        )

        // Prepare the user input text
        val textInput = TextInput.newBuilder().setText(prompt).build()

        // Construct a query input object with the user text and language code
        val queryInput = QueryInput.newBuilder()
            .setText(textInput)
            .setLanguageCode("EN")  // Set language to English
            .build()

        // Create a request to send the user query to Dialogflow CX
        val detectIntentRequest = DetectIntentRequest.newBuilder()
            .setSession(session.toString())  // Attach the session to maintain context
            .setQueryInput(queryInput)       // Include the user's query
            .build()

        // Send the request and receive a response from Dialogflow CX
        val response = sessionsClient.detectIntent(detectIntentRequest)

        // Close the SessionsClient to free up resources
        sessionsClient.close()

        // Extract the first text response from the Dialogflow agent's response messages
        val responseText = response.queryResult.responseMessagesList.first().text.getText(0)

        // Return the agent's response as a string
        responseText
    } catch (e: Exception) {
        // Handle any exceptions and print the error message
        println(e.message)
        ""
    }
}

Applying these steps in the application gives a simple means of getting a response if the given information is accurate.
I have left a sample application here in the repository for your reference:
https://github.com/shibinsv/Ask-Me.

Go ahead and take a look. Happy coding! 😊