A solid application always needs strong foundations. Today, let’s talk about something essential : Dependency Injection (DI). Sounds weird, maybe even illicit ? Don’t worry, it’s perfectly legal. 😏

So, what is DI ?

DI is all about providing the dependencies of a class from the outside. Let’s take a simple and tastyyy analogy here:

You‘re a cook (obvious right 🤌🏾), and you’re preparing a homemade burger. So you buy a burger buns to the bakery, the meat to the butcher shop, the lettuce and tomato to the grocery. You go to the bakery for the buns, the butcher for the meat, and the grocery store for the veggies. You know the recipe, but you’re responsible for gathering all the ingredients yourself.

Now imagine this :

With Dependency Injection, you don't have to fetch the ingredients yourself. You have a provider that delivers top-quality products right to your kitchen 🤤. And if you don’t like one of them? You can swap it out easily. That’s the power of DI, it lets you focus on your recipe, not the ingredients.

With DI you don’t need to buy the ingredients by yourself, you have a provider who delivers you the best products and if you don’t like them; you can change them. That is the power of injection, you focus only on your recipe not the ingredients.

How can I use it ?

For Android, we use Hilt, a DI library that simplifies the setup and removes most of the boilerplate code.

Before getting started, make sure to set up the necessary ustensiles :

In your top-level build-grade file, apply the KSP and Hilt plugins.

// Top-level build file where you can add configuration options common to all sub-projects/modules.
plugins {
   ...
    //Hilt
    alias(libs.plugins.ksp) apply false
    alias(libs.plugins.hilt) apply false

}

In your module-level file add the following :

plugins {
    ...
    alias(libs.plugins.ksp)
    alias(libs.plugins.hilt)
    id("com.google.protobuf") version "0.9.5" // Protobuf
}
...

protobuf {
    protoc {
        artifact = "com.google.protobuf:protoc:3.24.3"
    }
    generateProtoTasks {
        all().forEach { task ->
            task.builtins {
                create("java") {
                    option("lite")
                }
            }
        }
    }
}

dependencies {
    ...

    // DataStore preference
    implementation("androidx.datastore:datastore-preferences:1.1.7")

    // Hilt
    implementation("com.google.dagger:hilt-android:2.52")
    implementation("androidx.hilt:hilt-navigation-compose:1.2.0")
    implementation("androidx.hilt:hilt-work:1.2.0")
    ksp("com.google.dagger:hilt-compiler:2.52")

    // Protobuf
    implementation("com.google.protobuf:protobuf-javalite:3.24.3")
    implementation("androidx.datastore:datastore:1.1.7")


}

Here’s your 5-steps recipe:

1. Create a file in the root package

   Create your Application file in “app/(kotlin|java)/your/company/package/YourApplicationNameApplication.kt” :

    app/
    ├── src/
    │   └── main/
    │       ├── java/
    │       │   └── com/
    │       │       └── yourcompany/
    │       │           └── yourapp/
    │       │               └── YourApplicationNameApplication.kt
    │       └── res/
    │           └── ...
    ├── build.gradle
    └── ...
   

   YourApplicationNameApplication.kt :

    @HiltAndroidApp
    class YourApplicationNameApplication : Application() {
    }
   

2. Add your Application class to the AndroidManifest.xml

    <application
        android:name=".YourApplicationNameApplication"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        ... >
    </application>
   

3. Establish an entry point in your MainActivity with @AndroidEntryPoint

   Now that your Application class is set up, it’s time to tell Hilt where to start injecting things.

   To do that, you need to annotate your MainActivity (or any activity where you want to inject dependencies) with the @AndroidEntryPoint annotation.

   Here’s how it looks:

    import dagger.hilt.android.AndroidEntryPoint
   
    @AndroidEntryPoint
    class MainActivity : AppCompatActivity() {
        // Your code here
    }
   

   This makes MainActivity a valid entry point for Hilt. Without this annotation, Hilt won’t know it’s allowed to inject anything into this activity, so don’t skip it!

4. Create your Module file

   Now it’s time to tell Hilt how to create the objects (dependencies) your app needs. This is done in a Module, a Kotlin file where you define how to provide certain instances.

   Think of it as your kitchen assistant's cheat sheet: you write down how to prepare each ingredient, and they handle the rest.

   Here’s an example of a basic module:

    import dagger.Module
    import dagger.Provides
    import dagger.hilt.InstallIn
    import dagger.hilt.android.qualifiers.ApplicationContext
    import dagger.hilt.components.SingletonComponent
    import javax.inject.Singleton
   
    @Module
    @InstallIn(SingletonComponent::class)
    object AppModule {
   
        @Provides
        fun provideBurgerService(): BurgerService {
            return BurgerServiceImpl()
        }
   
        @Provides
        fun provideTomato(): Tomato {
            return Tomato(fresh = true)
        }
    }
   

   A few things to note:

   • @Module : tells Hilt this file contains dependency instructions.

   • @InstallIn(SingletonComponent::class) : defines the scope (how long the object lives).

   • @Provides : tells Hilt how to create the object when needed.

Now when you need one of these dependencies (like BurgerService) in your activity or class, just use @Inject, and voilà!

5. Annotate your ViewModel with @HiltViewModel

   When using ViewModels, you also need to let Hilt know that it should handle the injection for you.

   To do that:

   • Annotate your ViewModel class with @HiltViewModel.

   • Use @Inject on the constructor to specify the dependencies it needs.

Here’s an example:

    import dagger.hilt.android.lifecycle.HiltViewModel
    import javax.inject.Inject

    @HiltViewModel
    class BurgerViewModel @Inject constructor(
        private val burgerService: BurgerService
    ) : ViewModel() {

        fun cookBurger() {
            burgerService.makeBurger()
        }
    }

And in your Activity or Fragment, use the: by viewModels() delegate to get your ViewModel:

    @AndroidEntryPoint
    class MainActivity : AppCompatActivity() {

        private val viewModel: BurgerViewModel by viewModels()

        // Now you can use viewModel.cookBurger()
    }

And that’s it!

I hope this was useful! And Happy Kooktding !

⚠️ Want to see this in action ? Check out my DataStore article, I show how to use Dependency Injection there too ! [Link to article]

You're probably almost finished with your app and need something to store your user settings. DataStore is perfect for that !

Jetpack DataStore is a modern data storage solution that lets you store user settings or typed objects. It uses Coroutines and Flow to store data:

• Asynchronously: Read and write operations are done in the background, off the main thread, so there's no risk of ANR.

• Consistent: Ensures that your data remains accurate, even in case of failures or interruptions.

• Transactionally: When multiple values are changed, all changes are applied together, or none are. This prevents partial updates and inconsistent states.

Pretty cool, right? 😎
DataStore comes in two types:

• Preferences DataStore: Stores simple key-value pairs without a predefined schema. Note: it doesn't offer type safety.

• Proto DataStore: Allows you to persist typed objects but requires a predefined schema.

Alright, enough theory, let’s Koockt! 👨‍🍳

Preference Datastore

class PreferenceDSManager ( private val context: Context) {

    private val Context.dataStore: DataStore<Preferences> by preferencesDataStore(name ="settings")
    suspend fun <T> savePreference(key: Preferences.Key<T>, value:T) {
        context.dataStore.edit { prefs->
            prefs[key] = value
        }
    }

    fun <T> getPreference(key: Preferences.Key<T>): Flow<T?> {
        return  context.dataStore.data.map { prefs-> prefs[key] }

    }

    suspend fun <T> getPreferenceValue(key: Preferences.Key<T>, default: T) : T {
        return getPreference(key).first() ?:default
    }

}


object Keys {
    val KEY_BOOLEAN = booleanPreferencesKey("key_boolean")
    val KEY_STRING = stringPreferencesKey("key_string")
    val KEY_INT = intPreferencesKey("key_int")
}

Proto DataStore

You need 3 ingredients:

1. A schema

Create a .proto file in the app/src/main/proto/ directory. It defines the type of your persisted variables.
(See the Protocol Buffers language guide for details.)

syntax = "proto3";

option java_package = "com.codelog.datastorerecipe.datastore";
option java_multiple_files = true;

//User preferences
message Userpreferences {

  // Hour format
 bool boolPref = 1;

 string strField = 2;

 int32 numField = 3;

  // Contrast level
  enum ContrastLevel {
    MIN = 0;
    MEDIUM = 1;
    HARD  = 2;
  }

  ContrastLevel contrast_level = 4;

}

2. A Serializer

It's like a translator , it basically converts your Kotlin data into a format that matches your schema file.

/**
 * Serializer implementation for `Userpreferences` protocol buffer messages.
 *
 * This object provides methods to serialize and deserialize `Userpreferences` data
 * for use with Jetpack's DataStore. It ensures that all protocol buffer data
 * is properly handled, including setting a default value and managing error scenarios
 * when parsing from an input stream.
 *
 * The `defaultValue` property provides a way to define the initial default proto state,
 * while the serialization and deserialization logic is handled by overriding
 * the `readFrom` and `writeTo` methods.
 */
object PreferenceProtoSerializer : Serializer<Userpreferences> {

    /**
     * Provides the default value for the preferences model `Userpreferences`.
     *
     * This property returns an instance of `Userpreferences` that represents the default
     * state as defined by the `getDefaultInstance` method. It is typically used as the
     * initial or fallback value when no specific preference data has been set or when
     * retrieving the default state of the preferences object in the absence of user-defined data.
     *
     * The returned instance serves as a baseline for the preference data and ensures
     * consistency across the application whenever the default configuration is required.
     */
    override val defaultValue: Userpreferences
        get() = Userpreferences.getDefaultInstance()

    /**
     * Reads and deserializes a Userpreferences object from the provided InputStream.
     *
     * This method parses the InputStream to create an instance of Userpreferences using the
     * `parseFrom` method. If the InputStream cannot be parsed, an InvalidProtocolBufferException
     * is thrown to indicate the error.
     *
     * @param input The InputStream containing the serialized data to be read and parsed.
     * @return A Userpreferences instance deserialized from the provided InputStream.
     * @throws InvalidProtocolBufferException If the InputStream cannot be parsed into a Userpreferences object.
     */
    override suspend fun readFrom(input: InputStream): Userpreferences {
        try {
            return Userpreferences.parseFrom(input)
        } catch (e: InvalidProtocolBufferException) {
            throw InvalidProtocolBufferException("Cannot read proto.", e)
        }
    }

    /**
     * Writes the provided `UserPreferences` object to the specified `OutputStream`.
     *
     * @param t The `UserPreferences` instance to be written to the output stream.
     * @param output The `OutputStream` to which the `UserPreferences` instance will be serialized.
     */
    override suspend fun writeTo(
        t: Userpreferences,
        output: OutputStream
    ) {
        t.writeTo(output)
    }

}

3. And finally your class manager :

/**
 * A manager class for handling user preferences using Proto DataStore.
 *
 * This class provides functionality to save and retrieve strongly-typed user preferences
 * such as boolean, string, integer fields, and enums. The user preferences are stored
 * in a Proto DataStore file named "user_prefs.pb", utilizing a protobuf-based serialization mechanism.
 *
 * It is designed to efficiently manage user-specific customization settings persistently while providing
 * an interface for easy and straightforward operations.
 *
 * @constructor Initializes the manager with the given application context.
 * @param context The application context used for accessing the DataStore.
 */

class PreferenceProtoDSManager  ( private val context: Context) {

    /**
     * Extension property providing a `DataStore` instance configured to work with protobuf-based user preferences.
     * This property is scoped to a `Context` and utilizes the `PreferenceProtoSerializer` for serialization.
     *
     * The `userPreferencesDataStore` is used to manage persistent storage and retrieval of user-specific
     * preferences, including various fields such as boolean, string, integer, and enum types. The preferences
     * are stored in a file named "user_prefs.pb".
     *
     * - To read data, use the associated `data` property on the `DataStore` instance, which provides a flow of
     *   the `Userpreferences` object.
     * - To update data, use the `updateData` function on the `DataStore` instance with the current builder
     *   instance of `Userpreferences`.
     *
     * Example purposes include storing user customization settings, such as theme preferences or contrast levels.
     *
     * Errors during data reading are handled by emitting the default instance of `Userpreferences`.
     */
    private val Context.userPreferencesDataStore: DataStore<Userpreferences> by dataStore(
        fileName = "user_prefs.pb",
        serializer = PreferenceProtoSerializer
    )

    /**
     * A Flow that emits the user preferences data stored in the `userPreferencesDataStore`.
     *
     * This flow listens to changes in the underlying Proto DataStore and emits updated
     * `Userpreferences` objects whenever the data changes. In case of an exception during
     * data retrieval, it emits the default `Userpreferences` instance and logs the exception.
     *
     * The default instance of `Userpreferences` is provided by the `getDefaultInstance()` method.
     * Exceptions are caught and logged using `Log.e` to ensure seamless operations and handling
     * of fallback scenarios.
     */
    val userPreferencesFlow: Flow<Userpreferences> =context.userPreferencesDataStore.data
        .catch {  exception ->

            emit(Userpreferences.getDefaultInstance())
            Log.e ("Error"," PreferenceProtoDSManager::userPreferencesFlow message "+exception.message)
        }


    /**
     * Saves the given boolean preference value to the UserPreferences DataStore.
     *
     * @param boolPref The boolean value to be stored in the preferences.
     */
    suspend fun saveBoolPref(boolPref: Boolean) {
        context.userPreferencesDataStore.updateData {
            it.toBuilder().setBoolPref(boolPref).build()
        }
    }

    /**
     * Retrieves the boolean preference value from the UserPreferences DataStore.
     *
     * @return The boolean value stored in the preferences.
     */
    suspend fun getBoolPref(): Boolean {
        return context.userPreferencesDataStore.data.first().boolPref
    }

    /**
     * Saves the given string field value to the UserPreferences DataStore.
     *
     * @param strField The string value to be stored in the preferences.
     */
    suspend fun saveStrField(strField:String) {
        context.userPreferencesDataStore.updateData {
            it.toBuilder().setStrField(strField).build()
        }
    }

    /**
     * Retrieves the string field value from the UserPreferences DataStore.
     *
     * @return The string value stored in the preferences.
     */
    suspend fun getStrField() : String {
        return context.userPreferencesDataStore.data.first().strField
    }

    /**
     * Saves the given integer field value to the UserPreferences DataStore.
     *
     * @param numField The integer value to be stored in the preferences.
     */
    suspend fun saveNumField(numField:Int) {
        context.userPreferencesDataStore.updateData {
            it.toBuilder().setNumField(numField).build()
        }
    }

    /**
     * Retrieves the integer value of the numField from the UserPreferences DataStore.
     *
     * @return The integer value stored in the numField preference.
     */
    suspend fun getNumField() : Int {
        return context.userPreferencesDataStore.data.first().numField
    }

    /**
     * Saves the specified contrast level value to the UserPreferences DataStore.
     *
     * @param contrastLevel The contrast level value to be stored in the preferences.
     */
    suspend fun saveContrastLevel(contrastLevel: Userpreferences.ContrastLevel) {
        context.userPreferencesDataStore.updateData {
            it.toBuilder().setContrastLevel(contrastLevel).build()

        }
    }

    /**
     * Retrieves the contrast level preference value from the UserPreferences DataStore.
     * This function suspends while it fetches the data.
     *
     * @return The contrast level value stored in the UserPreferences DataStore.
     */
    suspend fun getContrastLevel() : Userpreferences.ContrastLevel {
        return context.userPreferencesDataStore.data.first().contrastLevel
    }



}

Thank you for reading.

I hope this was useful! And Happy Kooktding !

⚠️ For this recipe, I’m using Hilt for dependency injection. [Link to article]

You can find the source code here :